@salesforce/lwc-adapters-uiapi 1.158.2 → 1.159.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (2) hide show
  1. package/dist/main.js +289 -2494
  2. package/package.json +2 -2
package/dist/main.js CHANGED
@@ -364,7 +364,7 @@ var FragmentReadResultState;
364
364
  ({
365
365
  state: FragmentReadResultState.Missing,
366
366
  });
367
- // engine version: 0.143.4-64dccb30
367
+ // engine version: 0.143.5-e5a21255
368
368
 
369
369
  /**
370
370
  * Returns true if the value acts like a Promise, i.e. has a "then" function,
@@ -7478,6 +7478,17 @@ function createFragmentMap(documentNode) {
7478
7478
  return fragments;
7479
7479
  }
7480
7480
 
7481
+ function buildFieldState(state, fullPath, data) {
7482
+ return {
7483
+ ...state,
7484
+ path: {
7485
+ parent: null,
7486
+ propertyName: null,
7487
+ fullPath,
7488
+ },
7489
+ data,
7490
+ };
7491
+ }
7481
7492
  function serializeFieldArguments(argumentNodes, variables) {
7482
7493
  const mutableArgumentNodes = Object.assign([], argumentNodes);
7483
7494
  return `args__(${mutableArgumentNodes
@@ -38935,80 +38946,32 @@ function getTypeCacheKeys$18(astNode, state) {
38935
38946
  const fieldKey = getSerializedKeyForField(requestedField, state.variables, fieldType);
38936
38947
  switch (fieldType.typename) {
38937
38948
  case 'DoubleValue': {
38938
- const avgState = {
38939
- ...state,
38940
- path: {
38941
- parent: null,
38942
- propertyName: null,
38943
- fullPath: rootKey + '__' + fieldKey
38944
- },
38945
- data: fieldData,
38946
- };
38949
+ const avgState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
38947
38950
  cacheKeySink.merge(getTypeCacheKeys$1b(requestedField, avgState));
38948
38951
  break;
38949
38952
  }
38950
38953
  case 'LongValue': {
38951
- const countState = {
38952
- ...state,
38953
- path: {
38954
- parent: null,
38955
- propertyName: null,
38956
- fullPath: rootKey + '__' + fieldKey
38957
- },
38958
- data: fieldData,
38959
- };
38954
+ const countState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
38960
38955
  cacheKeySink.merge(getTypeCacheKeys$1a(requestedField, countState));
38961
38956
  break;
38962
38957
  }
38963
38958
  case 'LongValue': {
38964
- const countDistinctState = {
38965
- ...state,
38966
- path: {
38967
- parent: null,
38968
- propertyName: null,
38969
- fullPath: rootKey + '__' + fieldKey
38970
- },
38971
- data: fieldData,
38972
- };
38959
+ const countDistinctState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
38973
38960
  cacheKeySink.merge(getTypeCacheKeys$1a(requestedField, countDistinctState));
38974
38961
  break;
38975
38962
  }
38976
38963
  case 'PercentValue': {
38977
- const maxState = {
38978
- ...state,
38979
- path: {
38980
- parent: null,
38981
- propertyName: null,
38982
- fullPath: rootKey + '__' + fieldKey
38983
- },
38984
- data: fieldData,
38985
- };
38964
+ const maxState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
38986
38965
  cacheKeySink.merge(getTypeCacheKeys$19(requestedField, maxState));
38987
38966
  break;
38988
38967
  }
38989
38968
  case 'PercentValue': {
38990
- const minState = {
38991
- ...state,
38992
- path: {
38993
- parent: null,
38994
- propertyName: null,
38995
- fullPath: rootKey + '__' + fieldKey
38996
- },
38997
- data: fieldData,
38998
- };
38969
+ const minState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
38999
38970
  cacheKeySink.merge(getTypeCacheKeys$19(requestedField, minState));
39000
38971
  break;
39001
38972
  }
39002
38973
  case 'PercentValue': {
39003
- const sumState = {
39004
- ...state,
39005
- path: {
39006
- parent: null,
39007
- propertyName: null,
39008
- fullPath: rootKey + '__' + fieldKey
39009
- },
39010
- data: fieldData,
39011
- };
38974
+ const sumState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
39012
38975
  cacheKeySink.merge(getTypeCacheKeys$19(requestedField, sumState));
39013
38976
  break;
39014
38977
  }
@@ -39099,41 +39062,17 @@ function ingestFieldByType$_(typename, parentKey, requestedField, sink, fieldKey
39099
39062
  break;
39100
39063
  }
39101
39064
  case 'DoubleValue': {
39102
- const DoubleValueState = {
39103
- ...state,
39104
- path: {
39105
- parent: null,
39106
- propertyName: null,
39107
- fullPath: parentKey + '__' + fieldKey
39108
- },
39109
- data: fieldData,
39110
- };
39065
+ const DoubleValueState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
39111
39066
  sink[fieldKey] = ingest$1a(requestedField, DoubleValueState);
39112
39067
  break;
39113
39068
  }
39114
39069
  case 'LongValue': {
39115
- const LongValueState = {
39116
- ...state,
39117
- path: {
39118
- parent: null,
39119
- propertyName: null,
39120
- fullPath: parentKey + '__' + fieldKey
39121
- },
39122
- data: fieldData,
39123
- };
39070
+ const LongValueState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
39124
39071
  sink[fieldKey] = ingest$19(requestedField, LongValueState);
39125
39072
  break;
39126
39073
  }
39127
39074
  case 'PercentValue': {
39128
- const PercentValueState = {
39129
- ...state,
39130
- path: {
39131
- parent: null,
39132
- propertyName: null,
39133
- fullPath: parentKey + '__' + fieldKey
39134
- },
39135
- data: fieldData,
39136
- };
39075
+ const PercentValueState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
39137
39076
  sink[fieldKey] = ingest$18(requestedField, PercentValueState);
39138
39077
  break;
39139
39078
  }
@@ -39545,67 +39484,27 @@ function getTypeCacheKeys$15(astNode, state) {
39545
39484
  const fieldKey = getSerializedKeyForField(requestedField, state.variables, fieldType);
39546
39485
  switch (fieldType.typename) {
39547
39486
  case 'LongValue': {
39548
- const countState = {
39549
- ...state,
39550
- path: {
39551
- parent: null,
39552
- propertyName: null,
39553
- fullPath: rootKey + '__' + fieldKey
39554
- },
39555
- data: fieldData,
39556
- };
39487
+ const countState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
39557
39488
  cacheKeySink.merge(getTypeCacheKeys$1a(requestedField, countState));
39558
39489
  break;
39559
39490
  }
39560
39491
  case 'LongValue': {
39561
- const countDistinctState = {
39562
- ...state,
39563
- path: {
39564
- parent: null,
39565
- propertyName: null,
39566
- fullPath: rootKey + '__' + fieldKey
39567
- },
39568
- data: fieldData,
39569
- };
39492
+ const countDistinctState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
39570
39493
  cacheKeySink.merge(getTypeCacheKeys$1a(requestedField, countDistinctState));
39571
39494
  break;
39572
39495
  }
39573
39496
  case 'IntValue': {
39574
- const groupingState = {
39575
- ...state,
39576
- path: {
39577
- parent: null,
39578
- propertyName: null,
39579
- fullPath: rootKey + '__' + fieldKey
39580
- },
39581
- data: fieldData,
39582
- };
39497
+ const groupingState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
39583
39498
  cacheKeySink.merge(getTypeCacheKeys$17(requestedField, groupingState));
39584
39499
  break;
39585
39500
  }
39586
39501
  case 'StringValue': {
39587
- const maxState = {
39588
- ...state,
39589
- path: {
39590
- parent: null,
39591
- propertyName: null,
39592
- fullPath: rootKey + '__' + fieldKey
39593
- },
39594
- data: fieldData,
39595
- };
39502
+ const maxState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
39596
39503
  cacheKeySink.merge(getTypeCacheKeys$16(requestedField, maxState));
39597
39504
  break;
39598
39505
  }
39599
39506
  case 'StringValue': {
39600
- const minState = {
39601
- ...state,
39602
- path: {
39603
- parent: null,
39604
- propertyName: null,
39605
- fullPath: rootKey + '__' + fieldKey
39606
- },
39607
- data: fieldData,
39608
- };
39507
+ const minState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
39609
39508
  cacheKeySink.merge(getTypeCacheKeys$16(requestedField, minState));
39610
39509
  break;
39611
39510
  }
@@ -39686,41 +39585,17 @@ function ingestFieldByType$X(typename, parentKey, requestedField, sink, fieldKey
39686
39585
  break;
39687
39586
  }
39688
39587
  case 'LongValue': {
39689
- const LongValueState = {
39690
- ...state,
39691
- path: {
39692
- parent: null,
39693
- propertyName: null,
39694
- fullPath: parentKey + '__' + fieldKey
39695
- },
39696
- data: fieldData,
39697
- };
39588
+ const LongValueState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
39698
39589
  sink[fieldKey] = ingest$19(requestedField, LongValueState);
39699
39590
  break;
39700
39591
  }
39701
39592
  case 'IntValue': {
39702
- const IntValueState = {
39703
- ...state,
39704
- path: {
39705
- parent: null,
39706
- propertyName: null,
39707
- fullPath: parentKey + '__' + fieldKey
39708
- },
39709
- data: fieldData,
39710
- };
39593
+ const IntValueState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
39711
39594
  sink[fieldKey] = ingest$16(requestedField, IntValueState);
39712
39595
  break;
39713
39596
  }
39714
39597
  case 'StringValue': {
39715
- const StringValueState = {
39716
- ...state,
39717
- path: {
39718
- parent: null,
39719
- propertyName: null,
39720
- fullPath: parentKey + '__' + fieldKey
39721
- },
39722
- data: fieldData,
39723
- };
39598
+ const StringValueState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
39724
39599
  sink[fieldKey] = ingest$15(requestedField, StringValueState);
39725
39600
  break;
39726
39601
  }
@@ -40196,210 +40071,82 @@ function getTypeCacheKeys$12(astNode, state) {
40196
40071
  const fieldKey = getSerializedKeyForField(requestedField, state.variables, fieldType);
40197
40072
  switch (fieldType.typename) {
40198
40073
  case 'DateFunctionAggregation': {
40199
- const calendarMonthState = {
40200
- ...state,
40201
- path: {
40202
- parent: null,
40203
- propertyName: null,
40204
- fullPath: rootKey + '__' + fieldKey
40205
- },
40206
- data: fieldData,
40207
- };
40074
+ const calendarMonthState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
40208
40075
  cacheKeySink.merge(getTypeCacheKeys$14(requestedField, calendarMonthState));
40209
40076
  break;
40210
40077
  }
40211
40078
  case 'DateFunctionAggregation': {
40212
- const calendarQuarterState = {
40213
- ...state,
40214
- path: {
40215
- parent: null,
40216
- propertyName: null,
40217
- fullPath: rootKey + '__' + fieldKey
40218
- },
40219
- data: fieldData,
40220
- };
40079
+ const calendarQuarterState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
40221
40080
  cacheKeySink.merge(getTypeCacheKeys$14(requestedField, calendarQuarterState));
40222
40081
  break;
40223
40082
  }
40224
40083
  case 'DateFunctionAggregation': {
40225
- const calendarYearState = {
40226
- ...state,
40227
- path: {
40228
- parent: null,
40229
- propertyName: null,
40230
- fullPath: rootKey + '__' + fieldKey
40231
- },
40232
- data: fieldData,
40233
- };
40084
+ const calendarYearState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
40234
40085
  cacheKeySink.merge(getTypeCacheKeys$14(requestedField, calendarYearState));
40235
40086
  break;
40236
40087
  }
40237
40088
  case 'LongValue': {
40238
- const countState = {
40239
- ...state,
40240
- path: {
40241
- parent: null,
40242
- propertyName: null,
40243
- fullPath: rootKey + '__' + fieldKey
40244
- },
40245
- data: fieldData,
40246
- };
40089
+ const countState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
40247
40090
  cacheKeySink.merge(getTypeCacheKeys$1a(requestedField, countState));
40248
40091
  break;
40249
40092
  }
40250
40093
  case 'LongValue': {
40251
- const countDistinctState = {
40252
- ...state,
40253
- path: {
40254
- parent: null,
40255
- propertyName: null,
40256
- fullPath: rootKey + '__' + fieldKey
40257
- },
40258
- data: fieldData,
40259
- };
40094
+ const countDistinctState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
40260
40095
  cacheKeySink.merge(getTypeCacheKeys$1a(requestedField, countDistinctState));
40261
40096
  break;
40262
40097
  }
40263
40098
  case 'DateFunctionAggregation': {
40264
- const dayInMonthState = {
40265
- ...state,
40266
- path: {
40267
- parent: null,
40268
- propertyName: null,
40269
- fullPath: rootKey + '__' + fieldKey
40270
- },
40271
- data: fieldData,
40272
- };
40099
+ const dayInMonthState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
40273
40100
  cacheKeySink.merge(getTypeCacheKeys$14(requestedField, dayInMonthState));
40274
40101
  break;
40275
40102
  }
40276
40103
  case 'DateFunctionAggregation': {
40277
- const dayInWeekState = {
40278
- ...state,
40279
- path: {
40280
- parent: null,
40281
- propertyName: null,
40282
- fullPath: rootKey + '__' + fieldKey
40283
- },
40284
- data: fieldData,
40285
- };
40104
+ const dayInWeekState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
40286
40105
  cacheKeySink.merge(getTypeCacheKeys$14(requestedField, dayInWeekState));
40287
40106
  break;
40288
40107
  }
40289
40108
  case 'DateFunctionAggregation': {
40290
- const dayInYearState = {
40291
- ...state,
40292
- path: {
40293
- parent: null,
40294
- propertyName: null,
40295
- fullPath: rootKey + '__' + fieldKey
40296
- },
40297
- data: fieldData,
40298
- };
40109
+ const dayInYearState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
40299
40110
  cacheKeySink.merge(getTypeCacheKeys$14(requestedField, dayInYearState));
40300
40111
  break;
40301
40112
  }
40302
40113
  case 'DateFunctionAggregation': {
40303
- const fiscalMonthState = {
40304
- ...state,
40305
- path: {
40306
- parent: null,
40307
- propertyName: null,
40308
- fullPath: rootKey + '__' + fieldKey
40309
- },
40310
- data: fieldData,
40311
- };
40114
+ const fiscalMonthState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
40312
40115
  cacheKeySink.merge(getTypeCacheKeys$14(requestedField, fiscalMonthState));
40313
40116
  break;
40314
40117
  }
40315
40118
  case 'DateFunctionAggregation': {
40316
- const fiscalQuarterState = {
40317
- ...state,
40318
- path: {
40319
- parent: null,
40320
- propertyName: null,
40321
- fullPath: rootKey + '__' + fieldKey
40322
- },
40323
- data: fieldData,
40324
- };
40119
+ const fiscalQuarterState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
40325
40120
  cacheKeySink.merge(getTypeCacheKeys$14(requestedField, fiscalQuarterState));
40326
40121
  break;
40327
40122
  }
40328
40123
  case 'DateFunctionAggregation': {
40329
- const fiscalYearState = {
40330
- ...state,
40331
- path: {
40332
- parent: null,
40333
- propertyName: null,
40334
- fullPath: rootKey + '__' + fieldKey
40335
- },
40336
- data: fieldData,
40337
- };
40124
+ const fiscalYearState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
40338
40125
  cacheKeySink.merge(getTypeCacheKeys$14(requestedField, fiscalYearState));
40339
40126
  break;
40340
40127
  }
40341
40128
  case 'IntValue': {
40342
- const groupingState = {
40343
- ...state,
40344
- path: {
40345
- parent: null,
40346
- propertyName: null,
40347
- fullPath: rootKey + '__' + fieldKey
40348
- },
40349
- data: fieldData,
40350
- };
40129
+ const groupingState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
40351
40130
  cacheKeySink.merge(getTypeCacheKeys$17(requestedField, groupingState));
40352
40131
  break;
40353
40132
  }
40354
40133
  case 'DateValue': {
40355
- const maxState = {
40356
- ...state,
40357
- path: {
40358
- parent: null,
40359
- propertyName: null,
40360
- fullPath: rootKey + '__' + fieldKey
40361
- },
40362
- data: fieldData,
40363
- };
40134
+ const maxState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
40364
40135
  cacheKeySink.merge(getTypeCacheKeys$13(requestedField, maxState));
40365
40136
  break;
40366
40137
  }
40367
40138
  case 'DateValue': {
40368
- const minState = {
40369
- ...state,
40370
- path: {
40371
- parent: null,
40372
- propertyName: null,
40373
- fullPath: rootKey + '__' + fieldKey
40374
- },
40375
- data: fieldData,
40376
- };
40139
+ const minState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
40377
40140
  cacheKeySink.merge(getTypeCacheKeys$13(requestedField, minState));
40378
40141
  break;
40379
40142
  }
40380
40143
  case 'DateFunctionAggregation': {
40381
- const weekInMonthState = {
40382
- ...state,
40383
- path: {
40384
- parent: null,
40385
- propertyName: null,
40386
- fullPath: rootKey + '__' + fieldKey
40387
- },
40388
- data: fieldData,
40389
- };
40144
+ const weekInMonthState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
40390
40145
  cacheKeySink.merge(getTypeCacheKeys$14(requestedField, weekInMonthState));
40391
40146
  break;
40392
40147
  }
40393
40148
  case 'DateFunctionAggregation': {
40394
- const weekInYearState = {
40395
- ...state,
40396
- path: {
40397
- parent: null,
40398
- propertyName: null,
40399
- fullPath: rootKey + '__' + fieldKey
40400
- },
40401
- data: fieldData,
40402
- };
40149
+ const weekInYearState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
40403
40150
  cacheKeySink.merge(getTypeCacheKeys$14(requestedField, weekInYearState));
40404
40151
  break;
40405
40152
  }
@@ -40550,54 +40297,22 @@ function ingestFieldByType$U(typename, parentKey, requestedField, sink, fieldKey
40550
40297
  break;
40551
40298
  }
40552
40299
  case 'DateFunctionAggregation': {
40553
- const DateFunctionAggregationState = {
40554
- ...state,
40555
- path: {
40556
- parent: null,
40557
- propertyName: null,
40558
- fullPath: parentKey + '__' + fieldKey
40559
- },
40560
- data: fieldData,
40561
- };
40300
+ const DateFunctionAggregationState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
40562
40301
  sink[fieldKey] = ingest$13(requestedField, DateFunctionAggregationState);
40563
40302
  break;
40564
40303
  }
40565
40304
  case 'LongValue': {
40566
- const LongValueState = {
40567
- ...state,
40568
- path: {
40569
- parent: null,
40570
- propertyName: null,
40571
- fullPath: parentKey + '__' + fieldKey
40572
- },
40573
- data: fieldData,
40574
- };
40305
+ const LongValueState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
40575
40306
  sink[fieldKey] = ingest$19(requestedField, LongValueState);
40576
40307
  break;
40577
40308
  }
40578
40309
  case 'IntValue': {
40579
- const IntValueState = {
40580
- ...state,
40581
- path: {
40582
- parent: null,
40583
- propertyName: null,
40584
- fullPath: parentKey + '__' + fieldKey
40585
- },
40586
- data: fieldData,
40587
- };
40310
+ const IntValueState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
40588
40311
  sink[fieldKey] = ingest$16(requestedField, IntValueState);
40589
40312
  break;
40590
40313
  }
40591
40314
  case 'DateValue': {
40592
- const DateValueState = {
40593
- ...state,
40594
- path: {
40595
- parent: null,
40596
- propertyName: null,
40597
- fullPath: parentKey + '__' + fieldKey
40598
- },
40599
- data: fieldData,
40600
- };
40315
+ const DateValueState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
40601
40316
  sink[fieldKey] = ingest$12(requestedField, DateValueState);
40602
40317
  break;
40603
40318
  }
@@ -41065,15 +40780,7 @@ function getTypeCacheKeys$$(astNode, state) {
41065
40780
  const fieldKey = getSerializedKeyForField(requestedField, state.variables, fieldType);
41066
40781
  switch (fieldType.typename) {
41067
40782
  case 'ObjectInfo': {
41068
- const objectInfoState = {
41069
- ...state,
41070
- path: {
41071
- parent: null,
41072
- propertyName: null,
41073
- fullPath: rootKey + '__' + fieldKey
41074
- },
41075
- data: fieldData,
41076
- };
40783
+ const objectInfoState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
41077
40784
  cacheKeySink.merge(getTypeCacheKeys$W(requestedField, objectInfoState));
41078
40785
  break;
41079
40786
  }
@@ -41142,15 +40849,7 @@ function ingestFieldByType$R(typename, parentKey, requestedField, sink, fieldKey
41142
40849
  break;
41143
40850
  }
41144
40851
  case 'ObjectInfo': {
41145
- const ObjectInfoState = {
41146
- ...state,
41147
- path: {
41148
- parent: null,
41149
- propertyName: null,
41150
- fullPath: parentKey + '__' + fieldKey
41151
- },
41152
- data: fieldData,
41153
- };
40852
+ const ObjectInfoState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
41154
40853
  sink[fieldKey] = ingest$V(requestedField, ObjectInfoState);
41155
40854
  break;
41156
40855
  }
@@ -41596,15 +41295,7 @@ function getTypeCacheKeys$Y(astNode, state) {
41596
41295
  const fieldKey = getSerializedKeyForField(requestedField, state.variables, fieldType);
41597
41296
  switch (fieldType.typename) {
41598
41297
  case 'FilteredLookupInfo': {
41599
- const filteredLookupInfoState = {
41600
- ...state,
41601
- path: {
41602
- parent: null,
41603
- propertyName: null,
41604
- fullPath: rootKey + '__' + fieldKey
41605
- },
41606
- data: fieldData,
41607
- };
41298
+ const filteredLookupInfoState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
41608
41299
  cacheKeySink.merge(getTypeCacheKeys$Z(requestedField, filteredLookupInfoState));
41609
41300
  break;
41610
41301
  }
@@ -41840,15 +41531,7 @@ function ingestFieldByType$O(typename, parentKey, requestedField, sink, fieldKey
41840
41531
  break;
41841
41532
  }
41842
41533
  case 'FilteredLookupInfo': {
41843
- const FilteredLookupInfoState = {
41844
- ...state,
41845
- path: {
41846
- parent: null,
41847
- propertyName: null,
41848
- fullPath: parentKey + '__' + fieldKey
41849
- },
41850
- data: fieldData,
41851
- };
41534
+ const FilteredLookupInfoState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
41852
41535
  sink[fieldKey] = ingest$Y(requestedField, FilteredLookupInfoState);
41853
41536
  break;
41854
41537
  }
@@ -41857,15 +41540,7 @@ function ingestFieldByType$O(typename, parentKey, requestedField, sink, fieldKey
41857
41540
  break;
41858
41541
  }
41859
41542
  case 'ReferenceToInfo': {
41860
- const ReferenceToInfoState = {
41861
- ...state,
41862
- path: {
41863
- parent: null,
41864
- propertyName: null,
41865
- fullPath: parentKey + '__' + fieldKey
41866
- },
41867
- data: fieldData,
41868
- };
41543
+ const ReferenceToInfoState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
41869
41544
  sink[fieldKey] = ingest$U(requestedField, ReferenceToInfoState);
41870
41545
  break;
41871
41546
  }
@@ -42226,15 +41901,7 @@ function getTypeCacheKeys$W(astNode, state) {
42226
41901
  break;
42227
41902
  }
42228
41903
  case 'ThemeInfo': {
42229
- const themeInfoState = {
42230
- ...state,
42231
- path: {
42232
- parent: null,
42233
- propertyName: null,
42234
- fullPath: rootKey + '__' + fieldKey
42235
- },
42236
- data: fieldData,
42237
- };
41904
+ const themeInfoState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
42238
41905
  cacheKeySink.merge(getTypeCacheKeys$X(requestedField, themeInfoState));
42239
41906
  break;
42240
41907
  }
@@ -42387,15 +42054,7 @@ function ingestFieldByType$M(typename, parentKey, requestedField, sink, fieldKey
42387
42054
  break;
42388
42055
  }
42389
42056
  case 'ChildRelationship': {
42390
- const ChildRelationshipState = {
42391
- ...state,
42392
- path: {
42393
- parent: null,
42394
- propertyName: null,
42395
- fullPath: parentKey + '__' + fieldKey
42396
- },
42397
- data: fieldData,
42398
- };
42057
+ const ChildRelationshipState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
42399
42058
  sink[fieldKey] = ingest$_(requestedField, ChildRelationshipState);
42400
42059
  break;
42401
42060
  }
@@ -42408,54 +42067,22 @@ function ingestFieldByType$M(typename, parentKey, requestedField, sink, fieldKey
42408
42067
  break;
42409
42068
  }
42410
42069
  case 'DependentField': {
42411
- const DependentFieldState = {
42412
- ...state,
42413
- path: {
42414
- parent: null,
42415
- propertyName: null,
42416
- fullPath: parentKey + '__' + fieldKey
42417
- },
42418
- data: fieldData,
42419
- };
42070
+ const DependentFieldState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
42420
42071
  sink[fieldKey] = ingest$Z(requestedField, DependentFieldState);
42421
42072
  break;
42422
42073
  }
42423
42074
  case 'Field': {
42424
- const FieldState = {
42425
- ...state,
42426
- path: {
42427
- parent: null,
42428
- propertyName: null,
42429
- fullPath: parentKey + '__' + fieldKey
42430
- },
42431
- data: fieldData,
42432
- };
42075
+ const FieldState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
42433
42076
  sink[fieldKey] = ingest$X(requestedField, FieldState);
42434
42077
  break;
42435
42078
  }
42436
42079
  case 'RecordTypeInfo': {
42437
- const RecordTypeInfoState = {
42438
- ...state,
42439
- path: {
42440
- parent: null,
42441
- propertyName: null,
42442
- fullPath: parentKey + '__' + fieldKey
42443
- },
42444
- data: fieldData,
42445
- };
42080
+ const RecordTypeInfoState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
42446
42081
  sink[fieldKey] = ingest$10(requestedField, RecordTypeInfoState);
42447
42082
  break;
42448
42083
  }
42449
42084
  case 'ThemeInfo': {
42450
- const ThemeInfoState = {
42451
- ...state,
42452
- path: {
42453
- parent: null,
42454
- propertyName: null,
42455
- fullPath: parentKey + '__' + fieldKey
42456
- },
42457
- data: fieldData,
42458
- };
42085
+ const ThemeInfoState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
42459
42086
  sink[fieldKey] = ingest$W(requestedField, ThemeInfoState);
42460
42087
  break;
42461
42088
  }
@@ -42580,15 +42207,7 @@ function getTypeCacheKeys$V(astNode, state) {
42580
42207
  const fieldKey = getSerializedKeyForField(requestedField, state.variables, fieldType);
42581
42208
  switch (fieldType.typename) {
42582
42209
  case 'ObjectInfo': {
42583
- const objectInfoState = {
42584
- ...state,
42585
- path: {
42586
- parent: null,
42587
- propertyName: null,
42588
- fullPath: rootKey + '__' + fieldKey
42589
- },
42590
- data: fieldData,
42591
- };
42210
+ const objectInfoState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
42592
42211
  cacheKeySink.merge(getTypeCacheKeys$W(requestedField, objectInfoState));
42593
42212
  break;
42594
42213
  }
@@ -42639,15 +42258,7 @@ function ingestFieldByType$L(typename, parentKey, requestedField, sink, fieldKey
42639
42258
  break;
42640
42259
  }
42641
42260
  case 'ObjectInfo': {
42642
- const ObjectInfoState = {
42643
- ...state,
42644
- path: {
42645
- parent: null,
42646
- propertyName: null,
42647
- fullPath: parentKey + '__' + fieldKey
42648
- },
42649
- data: fieldData,
42650
- };
42261
+ const ObjectInfoState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
42651
42262
  sink[fieldKey] = ingest$V(requestedField, ObjectInfoState);
42652
42263
  break;
42653
42264
  }
@@ -43061,93 +42672,37 @@ function getTypeCacheKeys$S(astNode, state) {
43061
42672
  const fieldKey = getSerializedKeyForField(requestedField, state.variables, fieldType);
43062
42673
  switch (fieldType.typename) {
43063
42674
  case 'DoubleValue': {
43064
- const avgState = {
43065
- ...state,
43066
- path: {
43067
- parent: null,
43068
- propertyName: null,
43069
- fullPath: rootKey + '__' + fieldKey
43070
- },
43071
- data: fieldData,
43072
- };
42675
+ const avgState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
43073
42676
  cacheKeySink.merge(getTypeCacheKeys$1b(requestedField, avgState));
43074
42677
  break;
43075
42678
  }
43076
42679
  case 'LongValue': {
43077
- const countState = {
43078
- ...state,
43079
- path: {
43080
- parent: null,
43081
- propertyName: null,
43082
- fullPath: rootKey + '__' + fieldKey
43083
- },
43084
- data: fieldData,
43085
- };
42680
+ const countState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
43086
42681
  cacheKeySink.merge(getTypeCacheKeys$1a(requestedField, countState));
43087
42682
  break;
43088
42683
  }
43089
42684
  case 'LongValue': {
43090
- const countDistinctState = {
43091
- ...state,
43092
- path: {
43093
- parent: null,
43094
- propertyName: null,
43095
- fullPath: rootKey + '__' + fieldKey
43096
- },
43097
- data: fieldData,
43098
- };
42685
+ const countDistinctState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
43099
42686
  cacheKeySink.merge(getTypeCacheKeys$1a(requestedField, countDistinctState));
43100
42687
  break;
43101
42688
  }
43102
42689
  case 'IntValue': {
43103
- const groupingState = {
43104
- ...state,
43105
- path: {
43106
- parent: null,
43107
- propertyName: null,
43108
- fullPath: rootKey + '__' + fieldKey
43109
- },
43110
- data: fieldData,
43111
- };
42690
+ const groupingState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
43112
42691
  cacheKeySink.merge(getTypeCacheKeys$17(requestedField, groupingState));
43113
42692
  break;
43114
42693
  }
43115
42694
  case 'LongValue': {
43116
- const maxState = {
43117
- ...state,
43118
- path: {
43119
- parent: null,
43120
- propertyName: null,
43121
- fullPath: rootKey + '__' + fieldKey
43122
- },
43123
- data: fieldData,
43124
- };
42695
+ const maxState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
43125
42696
  cacheKeySink.merge(getTypeCacheKeys$1a(requestedField, maxState));
43126
42697
  break;
43127
42698
  }
43128
42699
  case 'LongValue': {
43129
- const minState = {
43130
- ...state,
43131
- path: {
43132
- parent: null,
43133
- propertyName: null,
43134
- fullPath: rootKey + '__' + fieldKey
43135
- },
43136
- data: fieldData,
43137
- };
42700
+ const minState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
43138
42701
  cacheKeySink.merge(getTypeCacheKeys$1a(requestedField, minState));
43139
42702
  break;
43140
42703
  }
43141
42704
  case 'LongValue': {
43142
- const sumState = {
43143
- ...state,
43144
- path: {
43145
- parent: null,
43146
- propertyName: null,
43147
- fullPath: rootKey + '__' + fieldKey
43148
- },
43149
- data: fieldData,
43150
- };
42705
+ const sumState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
43151
42706
  cacheKeySink.merge(getTypeCacheKeys$1a(requestedField, sumState));
43152
42707
  break;
43153
42708
  }
@@ -43244,41 +42799,17 @@ function ingestFieldByType$I(typename, parentKey, requestedField, sink, fieldKey
43244
42799
  break;
43245
42800
  }
43246
42801
  case 'DoubleValue': {
43247
- const DoubleValueState = {
43248
- ...state,
43249
- path: {
43250
- parent: null,
43251
- propertyName: null,
43252
- fullPath: parentKey + '__' + fieldKey
43253
- },
43254
- data: fieldData,
43255
- };
42802
+ const DoubleValueState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
43256
42803
  sink[fieldKey] = ingest$1a(requestedField, DoubleValueState);
43257
42804
  break;
43258
42805
  }
43259
42806
  case 'LongValue': {
43260
- const LongValueState = {
43261
- ...state,
43262
- path: {
43263
- parent: null,
43264
- propertyName: null,
43265
- fullPath: parentKey + '__' + fieldKey
43266
- },
43267
- data: fieldData,
43268
- };
42807
+ const LongValueState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
43269
42808
  sink[fieldKey] = ingest$19(requestedField, LongValueState);
43270
42809
  break;
43271
42810
  }
43272
42811
  case 'IntValue': {
43273
- const IntValueState = {
43274
- ...state,
43275
- path: {
43276
- parent: null,
43277
- propertyName: null,
43278
- fullPath: parentKey + '__' + fieldKey
43279
- },
43280
- data: fieldData,
43281
- };
42812
+ const IntValueState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
43282
42813
  sink[fieldKey] = ingest$16(requestedField, IntValueState);
43283
42814
  break;
43284
42815
  }
@@ -43554,67 +43085,27 @@ function getTypeCacheKeys$Q(astNode, state) {
43554
43085
  const fieldKey = getSerializedKeyForField(requestedField, state.variables, fieldType);
43555
43086
  switch (fieldType.typename) {
43556
43087
  case 'LongValue': {
43557
- const countState = {
43558
- ...state,
43559
- path: {
43560
- parent: null,
43561
- propertyName: null,
43562
- fullPath: rootKey + '__' + fieldKey
43563
- },
43564
- data: fieldData,
43565
- };
43088
+ const countState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
43566
43089
  cacheKeySink.merge(getTypeCacheKeys$1a(requestedField, countState));
43567
43090
  break;
43568
43091
  }
43569
43092
  case 'LongValue': {
43570
- const countDistinctState = {
43571
- ...state,
43572
- path: {
43573
- parent: null,
43574
- propertyName: null,
43575
- fullPath: rootKey + '__' + fieldKey
43576
- },
43577
- data: fieldData,
43578
- };
43093
+ const countDistinctState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
43579
43094
  cacheKeySink.merge(getTypeCacheKeys$1a(requestedField, countDistinctState));
43580
43095
  break;
43581
43096
  }
43582
43097
  case 'IntValue': {
43583
- const groupingState = {
43584
- ...state,
43585
- path: {
43586
- parent: null,
43587
- propertyName: null,
43588
- fullPath: rootKey + '__' + fieldKey
43589
- },
43590
- data: fieldData,
43591
- };
43098
+ const groupingState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
43592
43099
  cacheKeySink.merge(getTypeCacheKeys$17(requestedField, groupingState));
43593
43100
  break;
43594
43101
  }
43595
43102
  case 'PhoneNumberValue': {
43596
- const maxState = {
43597
- ...state,
43598
- path: {
43599
- parent: null,
43600
- propertyName: null,
43601
- fullPath: rootKey + '__' + fieldKey
43602
- },
43603
- data: fieldData,
43604
- };
43103
+ const maxState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
43605
43104
  cacheKeySink.merge(getTypeCacheKeys$R(requestedField, maxState));
43606
43105
  break;
43607
43106
  }
43608
43107
  case 'PhoneNumberValue': {
43609
- const minState = {
43610
- ...state,
43611
- path: {
43612
- parent: null,
43613
- propertyName: null,
43614
- fullPath: rootKey + '__' + fieldKey
43615
- },
43616
- data: fieldData,
43617
- };
43108
+ const minState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
43618
43109
  cacheKeySink.merge(getTypeCacheKeys$R(requestedField, minState));
43619
43110
  break;
43620
43111
  }
@@ -43693,41 +43184,17 @@ function ingestFieldByType$G(typename, parentKey, requestedField, sink, fieldKey
43693
43184
  break;
43694
43185
  }
43695
43186
  case 'LongValue': {
43696
- const LongValueState = {
43697
- ...state,
43698
- path: {
43699
- parent: null,
43700
- propertyName: null,
43701
- fullPath: parentKey + '__' + fieldKey
43702
- },
43703
- data: fieldData,
43704
- };
43187
+ const LongValueState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
43705
43188
  sink[fieldKey] = ingest$19(requestedField, LongValueState);
43706
43189
  break;
43707
43190
  }
43708
43191
  case 'IntValue': {
43709
- const IntValueState = {
43710
- ...state,
43711
- path: {
43712
- parent: null,
43713
- propertyName: null,
43714
- fullPath: parentKey + '__' + fieldKey
43715
- },
43716
- data: fieldData,
43717
- };
43192
+ const IntValueState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
43718
43193
  sink[fieldKey] = ingest$16(requestedField, IntValueState);
43719
43194
  break;
43720
43195
  }
43721
43196
  case 'PhoneNumberValue': {
43722
- const PhoneNumberValueState = {
43723
- ...state,
43724
- path: {
43725
- parent: null,
43726
- propertyName: null,
43727
- fullPath: parentKey + '__' + fieldKey
43728
- },
43729
- data: fieldData,
43730
- };
43197
+ const PhoneNumberValueState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
43731
43198
  sink[fieldKey] = ingest$Q(requestedField, PhoneNumberValueState);
43732
43199
  break;
43733
43200
  }
@@ -44153,80 +43620,32 @@ function getTypeCacheKeys$N(astNode, state) {
44153
43620
  const fieldKey = getSerializedKeyForField(requestedField, state.variables, fieldType);
44154
43621
  switch (fieldType.typename) {
44155
43622
  case 'DoubleValue': {
44156
- const avgState = {
44157
- ...state,
44158
- path: {
44159
- parent: null,
44160
- propertyName: null,
44161
- fullPath: rootKey + '__' + fieldKey
44162
- },
44163
- data: fieldData,
44164
- };
43623
+ const avgState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
44165
43624
  cacheKeySink.merge(getTypeCacheKeys$1b(requestedField, avgState));
44166
43625
  break;
44167
43626
  }
44168
43627
  case 'LongValue': {
44169
- const countState = {
44170
- ...state,
44171
- path: {
44172
- parent: null,
44173
- propertyName: null,
44174
- fullPath: rootKey + '__' + fieldKey
44175
- },
44176
- data: fieldData,
44177
- };
43628
+ const countState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
44178
43629
  cacheKeySink.merge(getTypeCacheKeys$1a(requestedField, countState));
44179
43630
  break;
44180
43631
  }
44181
43632
  case 'LongValue': {
44182
- const countDistinctState = {
44183
- ...state,
44184
- path: {
44185
- parent: null,
44186
- propertyName: null,
44187
- fullPath: rootKey + '__' + fieldKey
44188
- },
44189
- data: fieldData,
44190
- };
43633
+ const countDistinctState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
44191
43634
  cacheKeySink.merge(getTypeCacheKeys$1a(requestedField, countDistinctState));
44192
43635
  break;
44193
43636
  }
44194
43637
  case 'CurrencyValue': {
44195
- const maxState = {
44196
- ...state,
44197
- path: {
44198
- parent: null,
44199
- propertyName: null,
44200
- fullPath: rootKey + '__' + fieldKey
44201
- },
44202
- data: fieldData,
44203
- };
43638
+ const maxState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
44204
43639
  cacheKeySink.merge(getTypeCacheKeys$O(requestedField, maxState));
44205
43640
  break;
44206
43641
  }
44207
43642
  case 'CurrencyValue': {
44208
- const minState = {
44209
- ...state,
44210
- path: {
44211
- parent: null,
44212
- propertyName: null,
44213
- fullPath: rootKey + '__' + fieldKey
44214
- },
44215
- data: fieldData,
44216
- };
43643
+ const minState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
44217
43644
  cacheKeySink.merge(getTypeCacheKeys$O(requestedField, minState));
44218
43645
  break;
44219
43646
  }
44220
43647
  case 'CurrencyValue': {
44221
- const sumState = {
44222
- ...state,
44223
- path: {
44224
- parent: null,
44225
- propertyName: null,
44226
- fullPath: rootKey + '__' + fieldKey
44227
- },
44228
- data: fieldData,
44229
- };
43648
+ const sumState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
44230
43649
  cacheKeySink.merge(getTypeCacheKeys$O(requestedField, sumState));
44231
43650
  break;
44232
43651
  }
@@ -44317,41 +43736,17 @@ function ingestFieldByType$D(typename, parentKey, requestedField, sink, fieldKey
44317
43736
  break;
44318
43737
  }
44319
43738
  case 'DoubleValue': {
44320
- const DoubleValueState = {
44321
- ...state,
44322
- path: {
44323
- parent: null,
44324
- propertyName: null,
44325
- fullPath: parentKey + '__' + fieldKey
44326
- },
44327
- data: fieldData,
44328
- };
43739
+ const DoubleValueState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
44329
43740
  sink[fieldKey] = ingest$1a(requestedField, DoubleValueState);
44330
43741
  break;
44331
43742
  }
44332
43743
  case 'LongValue': {
44333
- const LongValueState = {
44334
- ...state,
44335
- path: {
44336
- parent: null,
44337
- propertyName: null,
44338
- fullPath: parentKey + '__' + fieldKey
44339
- },
44340
- data: fieldData,
44341
- };
43744
+ const LongValueState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
44342
43745
  sink[fieldKey] = ingest$19(requestedField, LongValueState);
44343
43746
  break;
44344
43747
  }
44345
43748
  case 'CurrencyValue': {
44346
- const CurrencyValueState = {
44347
- ...state,
44348
- path: {
44349
- parent: null,
44350
- propertyName: null,
44351
- fullPath: parentKey + '__' + fieldKey
44352
- },
44353
- data: fieldData,
44354
- };
43749
+ const CurrencyValueState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
44355
43750
  sink[fieldKey] = ingest$N(requestedField, CurrencyValueState);
44356
43751
  break;
44357
43752
  }
@@ -44919,67 +44314,27 @@ function getTypeCacheKeys$K(astNode, state) {
44919
44314
  const fieldKey = getSerializedKeyForField(requestedField, state.variables, fieldType);
44920
44315
  switch (fieldType.typename) {
44921
44316
  case 'LongValue': {
44922
- const countState = {
44923
- ...state,
44924
- path: {
44925
- parent: null,
44926
- propertyName: null,
44927
- fullPath: rootKey + '__' + fieldKey
44928
- },
44929
- data: fieldData,
44930
- };
44317
+ const countState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
44931
44318
  cacheKeySink.merge(getTypeCacheKeys$1a(requestedField, countState));
44932
44319
  break;
44933
44320
  }
44934
44321
  case 'LongValue': {
44935
- const countDistinctState = {
44936
- ...state,
44937
- path: {
44938
- parent: null,
44939
- propertyName: null,
44940
- fullPath: rootKey + '__' + fieldKey
44941
- },
44942
- data: fieldData,
44943
- };
44322
+ const countDistinctState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
44944
44323
  cacheKeySink.merge(getTypeCacheKeys$1a(requestedField, countDistinctState));
44945
44324
  break;
44946
44325
  }
44947
44326
  case 'IntValue': {
44948
- const groupingState = {
44949
- ...state,
44950
- path: {
44951
- parent: null,
44952
- propertyName: null,
44953
- fullPath: rootKey + '__' + fieldKey
44954
- },
44955
- data: fieldData,
44956
- };
44327
+ const groupingState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
44957
44328
  cacheKeySink.merge(getTypeCacheKeys$17(requestedField, groupingState));
44958
44329
  break;
44959
44330
  }
44960
44331
  case 'EmailValue': {
44961
- const maxState = {
44962
- ...state,
44963
- path: {
44964
- parent: null,
44965
- propertyName: null,
44966
- fullPath: rootKey + '__' + fieldKey
44967
- },
44968
- data: fieldData,
44969
- };
44332
+ const maxState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
44970
44333
  cacheKeySink.merge(getTypeCacheKeys$L(requestedField, maxState));
44971
44334
  break;
44972
44335
  }
44973
44336
  case 'EmailValue': {
44974
- const minState = {
44975
- ...state,
44976
- path: {
44977
- parent: null,
44978
- propertyName: null,
44979
- fullPath: rootKey + '__' + fieldKey
44980
- },
44981
- data: fieldData,
44982
- };
44337
+ const minState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
44983
44338
  cacheKeySink.merge(getTypeCacheKeys$L(requestedField, minState));
44984
44339
  break;
44985
44340
  }
@@ -45058,41 +44413,17 @@ function ingestFieldByType$A(typename, parentKey, requestedField, sink, fieldKey
45058
44413
  break;
45059
44414
  }
45060
44415
  case 'LongValue': {
45061
- const LongValueState = {
45062
- ...state,
45063
- path: {
45064
- parent: null,
45065
- propertyName: null,
45066
- fullPath: parentKey + '__' + fieldKey
45067
- },
45068
- data: fieldData,
45069
- };
44416
+ const LongValueState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
45070
44417
  sink[fieldKey] = ingest$19(requestedField, LongValueState);
45071
44418
  break;
45072
44419
  }
45073
44420
  case 'IntValue': {
45074
- const IntValueState = {
45075
- ...state,
45076
- path: {
45077
- parent: null,
45078
- propertyName: null,
45079
- fullPath: parentKey + '__' + fieldKey
45080
- },
45081
- data: fieldData,
45082
- };
44421
+ const IntValueState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
45083
44422
  sink[fieldKey] = ingest$16(requestedField, IntValueState);
45084
44423
  break;
45085
44424
  }
45086
44425
  case 'EmailValue': {
45087
- const EmailValueState = {
45088
- ...state,
45089
- path: {
45090
- parent: null,
45091
- propertyName: null,
45092
- fullPath: parentKey + '__' + fieldKey
45093
- },
45094
- data: fieldData,
45095
- };
44426
+ const EmailValueState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
45096
44427
  sink[fieldKey] = ingest$K(requestedField, EmailValueState);
45097
44428
  break;
45098
44429
  }
@@ -45504,15 +44835,7 @@ function getTypeCacheKeys$H(astNode, state) {
45504
44835
  const fieldKey = getSerializedKeyForField(requestedField, state.variables, fieldType);
45505
44836
  switch (fieldType.typename) {
45506
44837
  case 'DateFunctionAggregation': {
45507
- const hourInDayState = {
45508
- ...state,
45509
- path: {
45510
- parent: null,
45511
- propertyName: null,
45512
- fullPath: rootKey + '__' + fieldKey
45513
- },
45514
- data: fieldData,
45515
- };
44838
+ const hourInDayState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
45516
44839
  cacheKeySink.merge(getTypeCacheKeys$14(requestedField, hourInDayState));
45517
44840
  break;
45518
44841
  }
@@ -45573,15 +44896,7 @@ function ingestFieldByType$x(typename, parentKey, requestedField, sink, fieldKey
45573
44896
  break;
45574
44897
  }
45575
44898
  case 'DateFunctionAggregation': {
45576
- const DateFunctionAggregationState = {
45577
- ...state,
45578
- path: {
45579
- parent: null,
45580
- propertyName: null,
45581
- fullPath: parentKey + '__' + fieldKey
45582
- },
45583
- data: fieldData,
45584
- };
44899
+ const DateFunctionAggregationState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
45585
44900
  sink[fieldKey] = ingest$13(requestedField, DateFunctionAggregationState);
45586
44901
  break;
45587
44902
  }
@@ -45857,80 +45172,32 @@ function getTypeCacheKeys$F(astNode, state) {
45857
45172
  const fieldKey = getSerializedKeyForField(requestedField, state.variables, fieldType);
45858
45173
  switch (fieldType.typename) {
45859
45174
  case 'DoubleValue': {
45860
- const avgState = {
45861
- ...state,
45862
- path: {
45863
- parent: null,
45864
- propertyName: null,
45865
- fullPath: rootKey + '__' + fieldKey
45866
- },
45867
- data: fieldData,
45868
- };
45175
+ const avgState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
45869
45176
  cacheKeySink.merge(getTypeCacheKeys$1b(requestedField, avgState));
45870
45177
  break;
45871
45178
  }
45872
45179
  case 'LongValue': {
45873
- const countState = {
45874
- ...state,
45875
- path: {
45876
- parent: null,
45877
- propertyName: null,
45878
- fullPath: rootKey + '__' + fieldKey
45879
- },
45880
- data: fieldData,
45881
- };
45180
+ const countState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
45882
45181
  cacheKeySink.merge(getTypeCacheKeys$1a(requestedField, countState));
45883
45182
  break;
45884
45183
  }
45885
45184
  case 'LongValue': {
45886
- const countDistinctState = {
45887
- ...state,
45888
- path: {
45889
- parent: null,
45890
- propertyName: null,
45891
- fullPath: rootKey + '__' + fieldKey
45892
- },
45893
- data: fieldData,
45894
- };
45185
+ const countDistinctState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
45895
45186
  cacheKeySink.merge(getTypeCacheKeys$1a(requestedField, countDistinctState));
45896
45187
  break;
45897
45188
  }
45898
45189
  case 'LatitudeValue': {
45899
- const maxState = {
45900
- ...state,
45901
- path: {
45902
- parent: null,
45903
- propertyName: null,
45904
- fullPath: rootKey + '__' + fieldKey
45905
- },
45906
- data: fieldData,
45907
- };
45190
+ const maxState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
45908
45191
  cacheKeySink.merge(getTypeCacheKeys$G(requestedField, maxState));
45909
45192
  break;
45910
45193
  }
45911
45194
  case 'LatitudeValue': {
45912
- const minState = {
45913
- ...state,
45914
- path: {
45915
- parent: null,
45916
- propertyName: null,
45917
- fullPath: rootKey + '__' + fieldKey
45918
- },
45919
- data: fieldData,
45920
- };
45195
+ const minState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
45921
45196
  cacheKeySink.merge(getTypeCacheKeys$G(requestedField, minState));
45922
45197
  break;
45923
45198
  }
45924
45199
  case 'DoubleValue': {
45925
- const sumState = {
45926
- ...state,
45927
- path: {
45928
- parent: null,
45929
- propertyName: null,
45930
- fullPath: rootKey + '__' + fieldKey
45931
- },
45932
- data: fieldData,
45933
- };
45200
+ const sumState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
45934
45201
  cacheKeySink.merge(getTypeCacheKeys$1b(requestedField, sumState));
45935
45202
  break;
45936
45203
  }
@@ -46015,41 +45282,17 @@ function ingestFieldByType$v(typename, parentKey, requestedField, sink, fieldKey
46015
45282
  break;
46016
45283
  }
46017
45284
  case 'DoubleValue': {
46018
- const DoubleValueState = {
46019
- ...state,
46020
- path: {
46021
- parent: null,
46022
- propertyName: null,
46023
- fullPath: parentKey + '__' + fieldKey
46024
- },
46025
- data: fieldData,
46026
- };
45285
+ const DoubleValueState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
46027
45286
  sink[fieldKey] = ingest$1a(requestedField, DoubleValueState);
46028
45287
  break;
46029
45288
  }
46030
45289
  case 'LongValue': {
46031
- const LongValueState = {
46032
- ...state,
46033
- path: {
46034
- parent: null,
46035
- propertyName: null,
46036
- fullPath: parentKey + '__' + fieldKey
46037
- },
46038
- data: fieldData,
46039
- };
45290
+ const LongValueState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
46040
45291
  sink[fieldKey] = ingest$19(requestedField, LongValueState);
46041
45292
  break;
46042
45293
  }
46043
45294
  case 'LatitudeValue': {
46044
- const LatitudeValueState = {
46045
- ...state,
46046
- path: {
46047
- parent: null,
46048
- propertyName: null,
46049
- fullPath: parentKey + '__' + fieldKey
46050
- },
46051
- data: fieldData,
46052
- };
45295
+ const LatitudeValueState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
46053
45296
  sink[fieldKey] = ingest$F(requestedField, LatitudeValueState);
46054
45297
  break;
46055
45298
  }
@@ -46325,80 +45568,32 @@ function getTypeCacheKeys$D(astNode, state) {
46325
45568
  const fieldKey = getSerializedKeyForField(requestedField, state.variables, fieldType);
46326
45569
  switch (fieldType.typename) {
46327
45570
  case 'DoubleValue': {
46328
- const avgState = {
46329
- ...state,
46330
- path: {
46331
- parent: null,
46332
- propertyName: null,
46333
- fullPath: rootKey + '__' + fieldKey
46334
- },
46335
- data: fieldData,
46336
- };
45571
+ const avgState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
46337
45572
  cacheKeySink.merge(getTypeCacheKeys$1b(requestedField, avgState));
46338
45573
  break;
46339
45574
  }
46340
45575
  case 'LongValue': {
46341
- const countState = {
46342
- ...state,
46343
- path: {
46344
- parent: null,
46345
- propertyName: null,
46346
- fullPath: rootKey + '__' + fieldKey
46347
- },
46348
- data: fieldData,
46349
- };
45576
+ const countState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
46350
45577
  cacheKeySink.merge(getTypeCacheKeys$1a(requestedField, countState));
46351
45578
  break;
46352
45579
  }
46353
45580
  case 'LongValue': {
46354
- const countDistinctState = {
46355
- ...state,
46356
- path: {
46357
- parent: null,
46358
- propertyName: null,
46359
- fullPath: rootKey + '__' + fieldKey
46360
- },
46361
- data: fieldData,
46362
- };
45581
+ const countDistinctState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
46363
45582
  cacheKeySink.merge(getTypeCacheKeys$1a(requestedField, countDistinctState));
46364
45583
  break;
46365
45584
  }
46366
45585
  case 'LongitudeValue': {
46367
- const maxState = {
46368
- ...state,
46369
- path: {
46370
- parent: null,
46371
- propertyName: null,
46372
- fullPath: rootKey + '__' + fieldKey
46373
- },
46374
- data: fieldData,
46375
- };
45586
+ const maxState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
46376
45587
  cacheKeySink.merge(getTypeCacheKeys$U(requestedField, maxState));
46377
45588
  break;
46378
45589
  }
46379
45590
  case 'LongitudeValue': {
46380
- const minState = {
46381
- ...state,
46382
- path: {
46383
- parent: null,
46384
- propertyName: null,
46385
- fullPath: rootKey + '__' + fieldKey
46386
- },
46387
- data: fieldData,
46388
- };
45591
+ const minState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
46389
45592
  cacheKeySink.merge(getTypeCacheKeys$U(requestedField, minState));
46390
45593
  break;
46391
45594
  }
46392
45595
  case 'DoubleValue': {
46393
- const sumState = {
46394
- ...state,
46395
- path: {
46396
- parent: null,
46397
- propertyName: null,
46398
- fullPath: rootKey + '__' + fieldKey
46399
- },
46400
- data: fieldData,
46401
- };
45596
+ const sumState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
46402
45597
  cacheKeySink.merge(getTypeCacheKeys$1b(requestedField, sumState));
46403
45598
  break;
46404
45599
  }
@@ -46483,41 +45678,17 @@ function ingestFieldByType$t(typename, parentKey, requestedField, sink, fieldKey
46483
45678
  break;
46484
45679
  }
46485
45680
  case 'DoubleValue': {
46486
- const DoubleValueState = {
46487
- ...state,
46488
- path: {
46489
- parent: null,
46490
- propertyName: null,
46491
- fullPath: parentKey + '__' + fieldKey
46492
- },
46493
- data: fieldData,
46494
- };
45681
+ const DoubleValueState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
46495
45682
  sink[fieldKey] = ingest$1a(requestedField, DoubleValueState);
46496
45683
  break;
46497
45684
  }
46498
45685
  case 'LongValue': {
46499
- const LongValueState = {
46500
- ...state,
46501
- path: {
46502
- parent: null,
46503
- propertyName: null,
46504
- fullPath: parentKey + '__' + fieldKey
46505
- },
46506
- data: fieldData,
46507
- };
45686
+ const LongValueState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
46508
45687
  sink[fieldKey] = ingest$19(requestedField, LongValueState);
46509
45688
  break;
46510
45689
  }
46511
45690
  case 'LongitudeValue': {
46512
- const LongitudeValueState = {
46513
- ...state,
46514
- path: {
46515
- parent: null,
46516
- propertyName: null,
46517
- fullPath: parentKey + '__' + fieldKey
46518
- },
46519
- data: fieldData,
46520
- };
45691
+ const LongitudeValueState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
46521
45692
  sink[fieldKey] = ingest$T(requestedField, LongitudeValueState);
46522
45693
  break;
46523
45694
  }
@@ -46651,80 +45822,32 @@ function getTypeCacheKeys$C(astNode, state) {
46651
45822
  const fieldKey = getSerializedKeyForField(requestedField, state.variables, fieldType);
46652
45823
  switch (fieldType.typename) {
46653
45824
  case 'DoubleValue': {
46654
- const avgState = {
46655
- ...state,
46656
- path: {
46657
- parent: null,
46658
- propertyName: null,
46659
- fullPath: rootKey + '__' + fieldKey
46660
- },
46661
- data: fieldData,
46662
- };
45825
+ const avgState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
46663
45826
  cacheKeySink.merge(getTypeCacheKeys$1b(requestedField, avgState));
46664
45827
  break;
46665
45828
  }
46666
45829
  case 'LongValue': {
46667
- const countState = {
46668
- ...state,
46669
- path: {
46670
- parent: null,
46671
- propertyName: null,
46672
- fullPath: rootKey + '__' + fieldKey
46673
- },
46674
- data: fieldData,
46675
- };
45830
+ const countState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
46676
45831
  cacheKeySink.merge(getTypeCacheKeys$1a(requestedField, countState));
46677
45832
  break;
46678
45833
  }
46679
45834
  case 'LongValue': {
46680
- const countDistinctState = {
46681
- ...state,
46682
- path: {
46683
- parent: null,
46684
- propertyName: null,
46685
- fullPath: rootKey + '__' + fieldKey
46686
- },
46687
- data: fieldData,
46688
- };
45835
+ const countDistinctState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
46689
45836
  cacheKeySink.merge(getTypeCacheKeys$1a(requestedField, countDistinctState));
46690
45837
  break;
46691
45838
  }
46692
45839
  case 'DoubleValue': {
46693
- const maxState = {
46694
- ...state,
46695
- path: {
46696
- parent: null,
46697
- propertyName: null,
46698
- fullPath: rootKey + '__' + fieldKey
46699
- },
46700
- data: fieldData,
46701
- };
45840
+ const maxState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
46702
45841
  cacheKeySink.merge(getTypeCacheKeys$1b(requestedField, maxState));
46703
45842
  break;
46704
45843
  }
46705
45844
  case 'DoubleValue': {
46706
- const minState = {
46707
- ...state,
46708
- path: {
46709
- parent: null,
46710
- propertyName: null,
46711
- fullPath: rootKey + '__' + fieldKey
46712
- },
46713
- data: fieldData,
46714
- };
45845
+ const minState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
46715
45846
  cacheKeySink.merge(getTypeCacheKeys$1b(requestedField, minState));
46716
45847
  break;
46717
45848
  }
46718
45849
  case 'DoubleValue': {
46719
- const sumState = {
46720
- ...state,
46721
- path: {
46722
- parent: null,
46723
- propertyName: null,
46724
- fullPath: rootKey + '__' + fieldKey
46725
- },
46726
- data: fieldData,
46727
- };
45850
+ const sumState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
46728
45851
  cacheKeySink.merge(getTypeCacheKeys$1b(requestedField, sumState));
46729
45852
  break;
46730
45853
  }
@@ -46815,28 +45938,12 @@ function ingestFieldByType$s(typename, parentKey, requestedField, sink, fieldKey
46815
45938
  break;
46816
45939
  }
46817
45940
  case 'DoubleValue': {
46818
- const DoubleValueState = {
46819
- ...state,
46820
- path: {
46821
- parent: null,
46822
- propertyName: null,
46823
- fullPath: parentKey + '__' + fieldKey
46824
- },
46825
- data: fieldData,
46826
- };
45941
+ const DoubleValueState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
46827
45942
  sink[fieldKey] = ingest$1a(requestedField, DoubleValueState);
46828
45943
  break;
46829
45944
  }
46830
45945
  case 'LongValue': {
46831
- const LongValueState = {
46832
- ...state,
46833
- path: {
46834
- parent: null,
46835
- propertyName: null,
46836
- fullPath: parentKey + '__' + fieldKey
46837
- },
46838
- data: fieldData,
46839
- };
45946
+ const LongValueState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
46840
45947
  sink[fieldKey] = ingest$19(requestedField, LongValueState);
46841
45948
  break;
46842
45949
  }
@@ -47112,67 +46219,27 @@ function getTypeCacheKeys$A(astNode, state) {
47112
46219
  const fieldKey = getSerializedKeyForField(requestedField, state.variables, fieldType);
47113
46220
  switch (fieldType.typename) {
47114
46221
  case 'LongValue': {
47115
- const countState = {
47116
- ...state,
47117
- path: {
47118
- parent: null,
47119
- propertyName: null,
47120
- fullPath: rootKey + '__' + fieldKey
47121
- },
47122
- data: fieldData,
47123
- };
46222
+ const countState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
47124
46223
  cacheKeySink.merge(getTypeCacheKeys$1a(requestedField, countState));
47125
46224
  break;
47126
46225
  }
47127
46226
  case 'LongValue': {
47128
- const countDistinctState = {
47129
- ...state,
47130
- path: {
47131
- parent: null,
47132
- propertyName: null,
47133
- fullPath: rootKey + '__' + fieldKey
47134
- },
47135
- data: fieldData,
47136
- };
46227
+ const countDistinctState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
47137
46228
  cacheKeySink.merge(getTypeCacheKeys$1a(requestedField, countDistinctState));
47138
46229
  break;
47139
46230
  }
47140
46231
  case 'IntValue': {
47141
- const groupingState = {
47142
- ...state,
47143
- path: {
47144
- parent: null,
47145
- propertyName: null,
47146
- fullPath: rootKey + '__' + fieldKey
47147
- },
47148
- data: fieldData,
47149
- };
46232
+ const groupingState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
47150
46233
  cacheKeySink.merge(getTypeCacheKeys$17(requestedField, groupingState));
47151
46234
  break;
47152
46235
  }
47153
46236
  case 'IDValue': {
47154
- const maxState = {
47155
- ...state,
47156
- path: {
47157
- parent: null,
47158
- propertyName: null,
47159
- fullPath: rootKey + '__' + fieldKey
47160
- },
47161
- data: fieldData,
47162
- };
46237
+ const maxState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
47163
46238
  cacheKeySink.merge(getTypeCacheKeys$f(requestedField, maxState));
47164
46239
  break;
47165
46240
  }
47166
46241
  case 'IDValue': {
47167
- const minState = {
47168
- ...state,
47169
- path: {
47170
- parent: null,
47171
- propertyName: null,
47172
- fullPath: rootKey + '__' + fieldKey
47173
- },
47174
- data: fieldData,
47175
- };
46242
+ const minState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
47176
46243
  cacheKeySink.merge(getTypeCacheKeys$f(requestedField, minState));
47177
46244
  break;
47178
46245
  }
@@ -47251,41 +46318,17 @@ function ingestFieldByType$q(typename, parentKey, requestedField, sink, fieldKey
47251
46318
  break;
47252
46319
  }
47253
46320
  case 'LongValue': {
47254
- const LongValueState = {
47255
- ...state,
47256
- path: {
47257
- parent: null,
47258
- propertyName: null,
47259
- fullPath: parentKey + '__' + fieldKey
47260
- },
47261
- data: fieldData,
47262
- };
46321
+ const LongValueState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
47263
46322
  sink[fieldKey] = ingest$19(requestedField, LongValueState);
47264
46323
  break;
47265
46324
  }
47266
46325
  case 'IntValue': {
47267
- const IntValueState = {
47268
- ...state,
47269
- path: {
47270
- parent: null,
47271
- propertyName: null,
47272
- fullPath: parentKey + '__' + fieldKey
47273
- },
47274
- data: fieldData,
47275
- };
46326
+ const IntValueState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
47276
46327
  sink[fieldKey] = ingest$16(requestedField, IntValueState);
47277
46328
  break;
47278
46329
  }
47279
46330
  case 'IDValue': {
47280
- const IDValueState = {
47281
- ...state,
47282
- path: {
47283
- parent: null,
47284
- propertyName: null,
47285
- fullPath: parentKey + '__' + fieldKey
47286
- },
47287
- data: fieldData,
47288
- };
46331
+ const IDValueState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
47289
46332
  sink[fieldKey] = ingest$e(requestedField, IDValueState);
47290
46333
  break;
47291
46334
  }
@@ -47423,67 +46466,27 @@ function getTypeCacheKeys$z(astNode, state) {
47423
46466
  const fieldKey = getSerializedKeyForField(requestedField, state.variables, fieldType);
47424
46467
  switch (fieldType.typename) {
47425
46468
  case 'LongValue': {
47426
- const countState = {
47427
- ...state,
47428
- path: {
47429
- parent: null,
47430
- propertyName: null,
47431
- fullPath: rootKey + '__' + fieldKey
47432
- },
47433
- data: fieldData,
47434
- };
46469
+ const countState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
47435
46470
  cacheKeySink.merge(getTypeCacheKeys$1a(requestedField, countState));
47436
46471
  break;
47437
46472
  }
47438
46473
  case 'LongValue': {
47439
- const countDistinctState = {
47440
- ...state,
47441
- path: {
47442
- parent: null,
47443
- propertyName: null,
47444
- fullPath: rootKey + '__' + fieldKey
47445
- },
47446
- data: fieldData,
47447
- };
46474
+ const countDistinctState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
47448
46475
  cacheKeySink.merge(getTypeCacheKeys$1a(requestedField, countDistinctState));
47449
46476
  break;
47450
46477
  }
47451
46478
  case 'IntValue': {
47452
- const groupingState = {
47453
- ...state,
47454
- path: {
47455
- parent: null,
47456
- propertyName: null,
47457
- fullPath: rootKey + '__' + fieldKey
47458
- },
47459
- data: fieldData,
47460
- };
46479
+ const groupingState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
47461
46480
  cacheKeySink.merge(getTypeCacheKeys$17(requestedField, groupingState));
47462
46481
  break;
47463
46482
  }
47464
46483
  case 'UrlValue': {
47465
- const maxState = {
47466
- ...state,
47467
- path: {
47468
- parent: null,
47469
- propertyName: null,
47470
- fullPath: rootKey + '__' + fieldKey
47471
- },
47472
- data: fieldData,
47473
- };
46484
+ const maxState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
47474
46485
  cacheKeySink.merge(getTypeCacheKeys$T(requestedField, maxState));
47475
46486
  break;
47476
46487
  }
47477
46488
  case 'UrlValue': {
47478
- const minState = {
47479
- ...state,
47480
- path: {
47481
- parent: null,
47482
- propertyName: null,
47483
- fullPath: rootKey + '__' + fieldKey
47484
- },
47485
- data: fieldData,
47486
- };
46489
+ const minState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
47487
46490
  cacheKeySink.merge(getTypeCacheKeys$T(requestedField, minState));
47488
46491
  break;
47489
46492
  }
@@ -47562,41 +46565,17 @@ function ingestFieldByType$p(typename, parentKey, requestedField, sink, fieldKey
47562
46565
  break;
47563
46566
  }
47564
46567
  case 'LongValue': {
47565
- const LongValueState = {
47566
- ...state,
47567
- path: {
47568
- parent: null,
47569
- propertyName: null,
47570
- fullPath: parentKey + '__' + fieldKey
47571
- },
47572
- data: fieldData,
47573
- };
46568
+ const LongValueState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
47574
46569
  sink[fieldKey] = ingest$19(requestedField, LongValueState);
47575
46570
  break;
47576
46571
  }
47577
46572
  case 'IntValue': {
47578
- const IntValueState = {
47579
- ...state,
47580
- path: {
47581
- parent: null,
47582
- propertyName: null,
47583
- fullPath: parentKey + '__' + fieldKey
47584
- },
47585
- data: fieldData,
47586
- };
46573
+ const IntValueState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
47587
46574
  sink[fieldKey] = ingest$16(requestedField, IntValueState);
47588
46575
  break;
47589
46576
  }
47590
46577
  case 'UrlValue': {
47591
- const UrlValueState = {
47592
- ...state,
47593
- path: {
47594
- parent: null,
47595
- propertyName: null,
47596
- fullPath: parentKey + '__' + fieldKey
47597
- },
47598
- data: fieldData,
47599
- };
46578
+ const UrlValueState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
47600
46579
  sink[fieldKey] = ingest$S(requestedField, UrlValueState);
47601
46580
  break;
47602
46581
  }
@@ -47734,67 +46713,27 @@ function getTypeCacheKeys$y(astNode, state) {
47734
46713
  const fieldKey = getSerializedKeyForField(requestedField, state.variables, fieldType);
47735
46714
  switch (fieldType.typename) {
47736
46715
  case 'LongValue': {
47737
- const countState = {
47738
- ...state,
47739
- path: {
47740
- parent: null,
47741
- propertyName: null,
47742
- fullPath: rootKey + '__' + fieldKey
47743
- },
47744
- data: fieldData,
47745
- };
46716
+ const countState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
47746
46717
  cacheKeySink.merge(getTypeCacheKeys$1a(requestedField, countState));
47747
46718
  break;
47748
46719
  }
47749
46720
  case 'LongValue': {
47750
- const countDistinctState = {
47751
- ...state,
47752
- path: {
47753
- parent: null,
47754
- propertyName: null,
47755
- fullPath: rootKey + '__' + fieldKey
47756
- },
47757
- data: fieldData,
47758
- };
46721
+ const countDistinctState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
47759
46722
  cacheKeySink.merge(getTypeCacheKeys$1a(requestedField, countDistinctState));
47760
46723
  break;
47761
46724
  }
47762
46725
  case 'IntValue': {
47763
- const groupingState = {
47764
- ...state,
47765
- path: {
47766
- parent: null,
47767
- propertyName: null,
47768
- fullPath: rootKey + '__' + fieldKey
47769
- },
47770
- data: fieldData,
47771
- };
46726
+ const groupingState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
47772
46727
  cacheKeySink.merge(getTypeCacheKeys$17(requestedField, groupingState));
47773
46728
  break;
47774
46729
  }
47775
46730
  case 'TextAreaValue': {
47776
- const maxState = {
47777
- ...state,
47778
- path: {
47779
- parent: null,
47780
- propertyName: null,
47781
- fullPath: rootKey + '__' + fieldKey
47782
- },
47783
- data: fieldData,
47784
- };
46731
+ const maxState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
47785
46732
  cacheKeySink.merge(getTypeCacheKeys$B(requestedField, maxState));
47786
46733
  break;
47787
46734
  }
47788
46735
  case 'TextAreaValue': {
47789
- const minState = {
47790
- ...state,
47791
- path: {
47792
- parent: null,
47793
- propertyName: null,
47794
- fullPath: rootKey + '__' + fieldKey
47795
- },
47796
- data: fieldData,
47797
- };
46736
+ const minState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
47798
46737
  cacheKeySink.merge(getTypeCacheKeys$B(requestedField, minState));
47799
46738
  break;
47800
46739
  }
@@ -47873,41 +46812,17 @@ function ingestFieldByType$o(typename, parentKey, requestedField, sink, fieldKey
47873
46812
  break;
47874
46813
  }
47875
46814
  case 'LongValue': {
47876
- const LongValueState = {
47877
- ...state,
47878
- path: {
47879
- parent: null,
47880
- propertyName: null,
47881
- fullPath: parentKey + '__' + fieldKey
47882
- },
47883
- data: fieldData,
47884
- };
46815
+ const LongValueState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
47885
46816
  sink[fieldKey] = ingest$19(requestedField, LongValueState);
47886
46817
  break;
47887
46818
  }
47888
46819
  case 'IntValue': {
47889
- const IntValueState = {
47890
- ...state,
47891
- path: {
47892
- parent: null,
47893
- propertyName: null,
47894
- fullPath: parentKey + '__' + fieldKey
47895
- },
47896
- data: fieldData,
47897
- };
46820
+ const IntValueState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
47898
46821
  sink[fieldKey] = ingest$16(requestedField, IntValueState);
47899
46822
  break;
47900
46823
  }
47901
46824
  case 'TextAreaValue': {
47902
- const TextAreaValueState = {
47903
- ...state,
47904
- path: {
47905
- parent: null,
47906
- propertyName: null,
47907
- fullPath: parentKey + '__' + fieldKey
47908
- },
47909
- data: fieldData,
47910
- };
46825
+ const TextAreaValueState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
47911
46826
  sink[fieldKey] = ingest$A(requestedField, TextAreaValueState);
47912
46827
  break;
47913
46828
  }
@@ -48189,67 +47104,27 @@ function getTypeCacheKeys$w(astNode, state) {
48189
47104
  const fieldKey = getSerializedKeyForField(requestedField, state.variables, fieldType);
48190
47105
  switch (fieldType.typename) {
48191
47106
  case 'LongValue': {
48192
- const countState = {
48193
- ...state,
48194
- path: {
48195
- parent: null,
48196
- propertyName: null,
48197
- fullPath: rootKey + '__' + fieldKey
48198
- },
48199
- data: fieldData,
48200
- };
47107
+ const countState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
48201
47108
  cacheKeySink.merge(getTypeCacheKeys$1a(requestedField, countState));
48202
47109
  break;
48203
47110
  }
48204
47111
  case 'LongValue': {
48205
- const countDistinctState = {
48206
- ...state,
48207
- path: {
48208
- parent: null,
48209
- propertyName: null,
48210
- fullPath: rootKey + '__' + fieldKey
48211
- },
48212
- data: fieldData,
48213
- };
47112
+ const countDistinctState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
48214
47113
  cacheKeySink.merge(getTypeCacheKeys$1a(requestedField, countDistinctState));
48215
47114
  break;
48216
47115
  }
48217
47116
  case 'IntValue': {
48218
- const groupingState = {
48219
- ...state,
48220
- path: {
48221
- parent: null,
48222
- propertyName: null,
48223
- fullPath: rootKey + '__' + fieldKey
48224
- },
48225
- data: fieldData,
48226
- };
47117
+ const groupingState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
48227
47118
  cacheKeySink.merge(getTypeCacheKeys$17(requestedField, groupingState));
48228
47119
  break;
48229
47120
  }
48230
47121
  case 'PicklistValue': {
48231
- const maxState = {
48232
- ...state,
48233
- path: {
48234
- parent: null,
48235
- propertyName: null,
48236
- fullPath: rootKey + '__' + fieldKey
48237
- },
48238
- data: fieldData,
48239
- };
47122
+ const maxState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
48240
47123
  cacheKeySink.merge(getTypeCacheKeys$P(requestedField, maxState));
48241
47124
  break;
48242
47125
  }
48243
47126
  case 'PicklistValue': {
48244
- const minState = {
48245
- ...state,
48246
- path: {
48247
- parent: null,
48248
- propertyName: null,
48249
- fullPath: rootKey + '__' + fieldKey
48250
- },
48251
- data: fieldData,
48252
- };
47127
+ const minState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
48253
47128
  cacheKeySink.merge(getTypeCacheKeys$P(requestedField, minState));
48254
47129
  break;
48255
47130
  }
@@ -48334,41 +47209,17 @@ function ingestFieldByType$m(typename, parentKey, requestedField, sink, fieldKey
48334
47209
  break;
48335
47210
  }
48336
47211
  case 'LongValue': {
48337
- const LongValueState = {
48338
- ...state,
48339
- path: {
48340
- parent: null,
48341
- propertyName: null,
48342
- fullPath: parentKey + '__' + fieldKey
48343
- },
48344
- data: fieldData,
48345
- };
47212
+ const LongValueState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
48346
47213
  sink[fieldKey] = ingest$19(requestedField, LongValueState);
48347
47214
  break;
48348
47215
  }
48349
47216
  case 'IntValue': {
48350
- const IntValueState = {
48351
- ...state,
48352
- path: {
48353
- parent: null,
48354
- propertyName: null,
48355
- fullPath: parentKey + '__' + fieldKey
48356
- },
48357
- data: fieldData,
48358
- };
47217
+ const IntValueState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
48359
47218
  sink[fieldKey] = ingest$16(requestedField, IntValueState);
48360
47219
  break;
48361
47220
  }
48362
47221
  case 'PicklistValue': {
48363
- const PicklistValueState = {
48364
- ...state,
48365
- path: {
48366
- parent: null,
48367
- propertyName: null,
48368
- fullPath: parentKey + '__' + fieldKey
48369
- },
48370
- data: fieldData,
48371
- };
47222
+ const PicklistValueState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
48372
47223
  sink[fieldKey] = ingest$O(requestedField, PicklistValueState);
48373
47224
  break;
48374
47225
  }
@@ -48506,93 +47357,37 @@ function getTypeCacheKeys$v(astNode, state) {
48506
47357
  const fieldKey = getSerializedKeyForField(requestedField, state.variables, fieldType);
48507
47358
  switch (fieldType.typename) {
48508
47359
  case 'DoubleValue': {
48509
- const avgState = {
48510
- ...state,
48511
- path: {
48512
- parent: null,
48513
- propertyName: null,
48514
- fullPath: rootKey + '__' + fieldKey
48515
- },
48516
- data: fieldData,
48517
- };
47360
+ const avgState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
48518
47361
  cacheKeySink.merge(getTypeCacheKeys$1b(requestedField, avgState));
48519
47362
  break;
48520
47363
  }
48521
47364
  case 'LongValue': {
48522
- const countState = {
48523
- ...state,
48524
- path: {
48525
- parent: null,
48526
- propertyName: null,
48527
- fullPath: rootKey + '__' + fieldKey
48528
- },
48529
- data: fieldData,
48530
- };
47365
+ const countState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
48531
47366
  cacheKeySink.merge(getTypeCacheKeys$1a(requestedField, countState));
48532
47367
  break;
48533
47368
  }
48534
47369
  case 'LongValue': {
48535
- const countDistinctState = {
48536
- ...state,
48537
- path: {
48538
- parent: null,
48539
- propertyName: null,
48540
- fullPath: rootKey + '__' + fieldKey
48541
- },
48542
- data: fieldData,
48543
- };
47370
+ const countDistinctState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
48544
47371
  cacheKeySink.merge(getTypeCacheKeys$1a(requestedField, countDistinctState));
48545
47372
  break;
48546
47373
  }
48547
47374
  case 'IntValue': {
48548
- const groupingState = {
48549
- ...state,
48550
- path: {
48551
- parent: null,
48552
- propertyName: null,
48553
- fullPath: rootKey + '__' + fieldKey
48554
- },
48555
- data: fieldData,
48556
- };
47375
+ const groupingState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
48557
47376
  cacheKeySink.merge(getTypeCacheKeys$17(requestedField, groupingState));
48558
47377
  break;
48559
47378
  }
48560
47379
  case 'IntValue': {
48561
- const maxState = {
48562
- ...state,
48563
- path: {
48564
- parent: null,
48565
- propertyName: null,
48566
- fullPath: rootKey + '__' + fieldKey
48567
- },
48568
- data: fieldData,
48569
- };
47380
+ const maxState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
48570
47381
  cacheKeySink.merge(getTypeCacheKeys$17(requestedField, maxState));
48571
47382
  break;
48572
47383
  }
48573
47384
  case 'IntValue': {
48574
- const minState = {
48575
- ...state,
48576
- path: {
48577
- parent: null,
48578
- propertyName: null,
48579
- fullPath: rootKey + '__' + fieldKey
48580
- },
48581
- data: fieldData,
48582
- };
47385
+ const minState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
48583
47386
  cacheKeySink.merge(getTypeCacheKeys$17(requestedField, minState));
48584
47387
  break;
48585
47388
  }
48586
47389
  case 'LongValue': {
48587
- const sumState = {
48588
- ...state,
48589
- path: {
48590
- parent: null,
48591
- propertyName: null,
48592
- fullPath: rootKey + '__' + fieldKey
48593
- },
48594
- data: fieldData,
48595
- };
47390
+ const sumState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
48596
47391
  cacheKeySink.merge(getTypeCacheKeys$1a(requestedField, sumState));
48597
47392
  break;
48598
47393
  }
@@ -48689,41 +47484,17 @@ function ingestFieldByType$l(typename, parentKey, requestedField, sink, fieldKey
48689
47484
  break;
48690
47485
  }
48691
47486
  case 'DoubleValue': {
48692
- const DoubleValueState = {
48693
- ...state,
48694
- path: {
48695
- parent: null,
48696
- propertyName: null,
48697
- fullPath: parentKey + '__' + fieldKey
48698
- },
48699
- data: fieldData,
48700
- };
47487
+ const DoubleValueState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
48701
47488
  sink[fieldKey] = ingest$1a(requestedField, DoubleValueState);
48702
47489
  break;
48703
47490
  }
48704
47491
  case 'LongValue': {
48705
- const LongValueState = {
48706
- ...state,
48707
- path: {
48708
- parent: null,
48709
- propertyName: null,
48710
- fullPath: parentKey + '__' + fieldKey
48711
- },
48712
- data: fieldData,
48713
- };
47492
+ const LongValueState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
48714
47493
  sink[fieldKey] = ingest$19(requestedField, LongValueState);
48715
47494
  break;
48716
47495
  }
48717
47496
  case 'IntValue': {
48718
- const IntValueState = {
48719
- ...state,
48720
- path: {
48721
- parent: null,
48722
- propertyName: null,
48723
- fullPath: parentKey + '__' + fieldKey
48724
- },
48725
- data: fieldData,
48726
- };
47497
+ const IntValueState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
48727
47498
  sink[fieldKey] = ingest$16(requestedField, IntValueState);
48728
47499
  break;
48729
47500
  }
@@ -48991,15 +47762,7 @@ function getTypeCacheKeys$t(astNode, state) {
48991
47762
  const fieldKey = getSerializedKeyForField(requestedField, state.variables, fieldType);
48992
47763
  switch (fieldType.typename) {
48993
47764
  case 'IntValue': {
48994
- const groupingState = {
48995
- ...state,
48996
- path: {
48997
- parent: null,
48998
- propertyName: null,
48999
- fullPath: rootKey + '__' + fieldKey
49000
- },
49001
- data: fieldData,
49002
- };
47765
+ const groupingState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
49003
47766
  cacheKeySink.merge(getTypeCacheKeys$17(requestedField, groupingState));
49004
47767
  break;
49005
47768
  }
@@ -49054,15 +47817,7 @@ function ingestFieldByType$j(typename, parentKey, requestedField, sink, fieldKey
49054
47817
  break;
49055
47818
  }
49056
47819
  case 'IntValue': {
49057
- const IntValueState = {
49058
- ...state,
49059
- path: {
49060
- parent: null,
49061
- propertyName: null,
49062
- fullPath: parentKey + '__' + fieldKey
49063
- },
49064
- data: fieldData,
49065
- };
47820
+ const IntValueState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
49066
47821
  sink[fieldKey] = ingest$16(requestedField, IntValueState);
49067
47822
  break;
49068
47823
  }
@@ -49918,28 +48673,12 @@ function ingestFieldByType$e(typename, parentKey, requestedField, sink, fieldKey
49918
48673
  break;
49919
48674
  }
49920
48675
  case 'ListColumn': {
49921
- const ListColumnState = {
49922
- ...state,
49923
- path: {
49924
- parent: null,
49925
- propertyName: null,
49926
- fullPath: parentKey + '__' + fieldKey
49927
- },
49928
- data: fieldData,
49929
- };
48676
+ const ListColumnState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
49930
48677
  sink[fieldKey] = ingest$p(requestedField, ListColumnState);
49931
48678
  break;
49932
48679
  }
49933
48680
  case 'ListOrder': {
49934
- const ListOrderState = {
49935
- ...state,
49936
- path: {
49937
- parent: null,
49938
- propertyName: null,
49939
- fullPath: parentKey + '__' + fieldKey
49940
- },
49941
- data: fieldData,
49942
- };
48681
+ const ListOrderState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
49943
48682
  sink[fieldKey] = ingest$o(requestedField, ListOrderState);
49944
48683
  break;
49945
48684
  }
@@ -50328,223 +49067,87 @@ function getTypeCacheKeys$m(astNode, state) {
50328
49067
  const fieldKey = getSerializedKeyForField(requestedField, state.variables, fieldType);
50329
49068
  switch (fieldType.typename) {
50330
49069
  case 'BooleanAggregate': {
50331
- const BooleanAggregateState = {
50332
- ...state,
50333
- path: {
50334
- parent: null,
50335
- propertyName: null,
50336
- fullPath: rootKey + '__' + fieldKey
50337
- },
50338
- data: fieldData,
50339
- };
49070
+ const BooleanAggregateState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
50340
49071
  cacheKeySink.merge(getTypeCacheKeys$t(requestedField, BooleanAggregateState));
50341
49072
  break;
50342
49073
  }
50343
49074
  case 'CurrencyAggregate': {
50344
- const CurrencyAggregateState = {
50345
- ...state,
50346
- path: {
50347
- parent: null,
50348
- propertyName: null,
50349
- fullPath: rootKey + '__' + fieldKey
50350
- },
50351
- data: fieldData,
50352
- };
49075
+ const CurrencyAggregateState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
50353
49076
  cacheKeySink.merge(getTypeCacheKeys$N(requestedField, CurrencyAggregateState));
50354
49077
  break;
50355
49078
  }
50356
49079
  case 'DateAggregate': {
50357
- const DateAggregateState = {
50358
- ...state,
50359
- path: {
50360
- parent: null,
50361
- propertyName: null,
50362
- fullPath: rootKey + '__' + fieldKey
50363
- },
50364
- data: fieldData,
50365
- };
49080
+ const DateAggregateState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
50366
49081
  cacheKeySink.merge(getTypeCacheKeys$12(requestedField, DateAggregateState));
50367
49082
  break;
50368
49083
  }
50369
49084
  case 'DoubleAggregate': {
50370
- const DoubleAggregateState = {
50371
- ...state,
50372
- path: {
50373
- parent: null,
50374
- propertyName: null,
50375
- fullPath: rootKey + '__' + fieldKey
50376
- },
50377
- data: fieldData,
50378
- };
49085
+ const DoubleAggregateState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
50379
49086
  cacheKeySink.merge(getTypeCacheKeys$C(requestedField, DoubleAggregateState));
50380
49087
  break;
50381
49088
  }
50382
49089
  case 'EmailAggregate': {
50383
- const EmailAggregateState = {
50384
- ...state,
50385
- path: {
50386
- parent: null,
50387
- propertyName: null,
50388
- fullPath: rootKey + '__' + fieldKey
50389
- },
50390
- data: fieldData,
50391
- };
49090
+ const EmailAggregateState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
50392
49091
  cacheKeySink.merge(getTypeCacheKeys$K(requestedField, EmailAggregateState));
50393
49092
  break;
50394
49093
  }
50395
49094
  case 'IDAggregate': {
50396
- const IDAggregateState = {
50397
- ...state,
50398
- path: {
50399
- parent: null,
50400
- propertyName: null,
50401
- fullPath: rootKey + '__' + fieldKey
50402
- },
50403
- data: fieldData,
50404
- };
49095
+ const IDAggregateState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
50405
49096
  cacheKeySink.merge(getTypeCacheKeys$A(requestedField, IDAggregateState));
50406
49097
  break;
50407
49098
  }
50408
49099
  case 'IntAggregate': {
50409
- const IntAggregateState = {
50410
- ...state,
50411
- path: {
50412
- parent: null,
50413
- propertyName: null,
50414
- fullPath: rootKey + '__' + fieldKey
50415
- },
50416
- data: fieldData,
50417
- };
49100
+ const IntAggregateState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
50418
49101
  cacheKeySink.merge(getTypeCacheKeys$v(requestedField, IntAggregateState));
50419
49102
  break;
50420
49103
  }
50421
49104
  case 'LatitudeAggregate': {
50422
- const LatitudeAggregateState = {
50423
- ...state,
50424
- path: {
50425
- parent: null,
50426
- propertyName: null,
50427
- fullPath: rootKey + '__' + fieldKey
50428
- },
50429
- data: fieldData,
50430
- };
49105
+ const LatitudeAggregateState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
50431
49106
  cacheKeySink.merge(getTypeCacheKeys$F(requestedField, LatitudeAggregateState));
50432
49107
  break;
50433
49108
  }
50434
49109
  case 'LongitudeAggregate': {
50435
- const LongitudeAggregateState = {
50436
- ...state,
50437
- path: {
50438
- parent: null,
50439
- propertyName: null,
50440
- fullPath: rootKey + '__' + fieldKey
50441
- },
50442
- data: fieldData,
50443
- };
49110
+ const LongitudeAggregateState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
50444
49111
  cacheKeySink.merge(getTypeCacheKeys$D(requestedField, LongitudeAggregateState));
50445
49112
  break;
50446
49113
  }
50447
49114
  case 'LongAggregate': {
50448
- const LongAggregateState = {
50449
- ...state,
50450
- path: {
50451
- parent: null,
50452
- propertyName: null,
50453
- fullPath: rootKey + '__' + fieldKey
50454
- },
50455
- data: fieldData,
50456
- };
49115
+ const LongAggregateState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
50457
49116
  cacheKeySink.merge(getTypeCacheKeys$S(requestedField, LongAggregateState));
50458
49117
  break;
50459
49118
  }
50460
49119
  case 'PercentAggregate': {
50461
- const PercentAggregateState = {
50462
- ...state,
50463
- path: {
50464
- parent: null,
50465
- propertyName: null,
50466
- fullPath: rootKey + '__' + fieldKey
50467
- },
50468
- data: fieldData,
50469
- };
49120
+ const PercentAggregateState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
50470
49121
  cacheKeySink.merge(getTypeCacheKeys$18(requestedField, PercentAggregateState));
50471
49122
  break;
50472
49123
  }
50473
49124
  case 'PhoneNumberAggregate': {
50474
- const PhoneNumberAggregateState = {
50475
- ...state,
50476
- path: {
50477
- parent: null,
50478
- propertyName: null,
50479
- fullPath: rootKey + '__' + fieldKey
50480
- },
50481
- data: fieldData,
50482
- };
49125
+ const PhoneNumberAggregateState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
50483
49126
  cacheKeySink.merge(getTypeCacheKeys$Q(requestedField, PhoneNumberAggregateState));
50484
49127
  break;
50485
49128
  }
50486
49129
  case 'PicklistAggregate': {
50487
- const PicklistAggregateState = {
50488
- ...state,
50489
- path: {
50490
- parent: null,
50491
- propertyName: null,
50492
- fullPath: rootKey + '__' + fieldKey
50493
- },
50494
- data: fieldData,
50495
- };
49130
+ const PicklistAggregateState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
50496
49131
  cacheKeySink.merge(getTypeCacheKeys$w(requestedField, PicklistAggregateState));
50497
49132
  break;
50498
49133
  }
50499
49134
  case 'StringAggregate': {
50500
- const StringAggregateState = {
50501
- ...state,
50502
- path: {
50503
- parent: null,
50504
- propertyName: null,
50505
- fullPath: rootKey + '__' + fieldKey
50506
- },
50507
- data: fieldData,
50508
- };
49135
+ const StringAggregateState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
50509
49136
  cacheKeySink.merge(getTypeCacheKeys$15(requestedField, StringAggregateState));
50510
49137
  break;
50511
49138
  }
50512
49139
  case 'TextAreaAggregate': {
50513
- const TextAreaAggregateState = {
50514
- ...state,
50515
- path: {
50516
- parent: null,
50517
- propertyName: null,
50518
- fullPath: rootKey + '__' + fieldKey
50519
- },
50520
- data: fieldData,
50521
- };
49140
+ const TextAreaAggregateState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
50522
49141
  cacheKeySink.merge(getTypeCacheKeys$y(requestedField, TextAreaAggregateState));
50523
49142
  break;
50524
49143
  }
50525
49144
  case 'TimeAggregate': {
50526
- const TimeAggregateState = {
50527
- ...state,
50528
- path: {
50529
- parent: null,
50530
- propertyName: null,
50531
- fullPath: rootKey + '__' + fieldKey
50532
- },
50533
- data: fieldData,
50534
- };
49145
+ const TimeAggregateState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
50535
49146
  cacheKeySink.merge(getTypeCacheKeys$H(requestedField, TimeAggregateState));
50536
49147
  break;
50537
49148
  }
50538
49149
  case 'UrlAggregate': {
50539
- const UrlAggregateState = {
50540
- ...state,
50541
- path: {
50542
- parent: null,
50543
- propertyName: null,
50544
- fullPath: rootKey + '__' + fieldKey
50545
- },
50546
- data: fieldData,
50547
- };
49150
+ const UrlAggregateState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
50548
49151
  cacheKeySink.merge(getTypeCacheKeys$z(requestedField, UrlAggregateState));
50549
49152
  break;
50550
49153
  }
@@ -50565,223 +49168,87 @@ function ingestFieldByType$d(typename, parentKey, requestedField, sink, fieldKey
50565
49168
  break;
50566
49169
  }
50567
49170
  case 'BooleanAggregate': {
50568
- const BooleanAggregateState = {
50569
- ...state,
50570
- path: {
50571
- parent: null,
50572
- propertyName: null,
50573
- fullPath: parentKey + '__' + fieldKey
50574
- },
50575
- data: fieldData,
50576
- };
49171
+ const BooleanAggregateState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
50577
49172
  sink[fieldKey] = ingest$s(requestedField, BooleanAggregateState);
50578
49173
  break;
50579
49174
  }
50580
49175
  case 'CurrencyAggregate': {
50581
- const CurrencyAggregateState = {
50582
- ...state,
50583
- path: {
50584
- parent: null,
50585
- propertyName: null,
50586
- fullPath: parentKey + '__' + fieldKey
50587
- },
50588
- data: fieldData,
50589
- };
49176
+ const CurrencyAggregateState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
50590
49177
  sink[fieldKey] = ingest$M(requestedField, CurrencyAggregateState);
50591
49178
  break;
50592
49179
  }
50593
49180
  case 'DateAggregate': {
50594
- const DateAggregateState = {
50595
- ...state,
50596
- path: {
50597
- parent: null,
50598
- propertyName: null,
50599
- fullPath: parentKey + '__' + fieldKey
50600
- },
50601
- data: fieldData,
50602
- };
49181
+ const DateAggregateState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
50603
49182
  sink[fieldKey] = ingest$11(requestedField, DateAggregateState);
50604
49183
  break;
50605
49184
  }
50606
49185
  case 'DoubleAggregate': {
50607
- const DoubleAggregateState = {
50608
- ...state,
50609
- path: {
50610
- parent: null,
50611
- propertyName: null,
50612
- fullPath: parentKey + '__' + fieldKey
50613
- },
50614
- data: fieldData,
50615
- };
49186
+ const DoubleAggregateState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
50616
49187
  sink[fieldKey] = ingest$B(requestedField, DoubleAggregateState);
50617
49188
  break;
50618
49189
  }
50619
49190
  case 'EmailAggregate': {
50620
- const EmailAggregateState = {
50621
- ...state,
50622
- path: {
50623
- parent: null,
50624
- propertyName: null,
50625
- fullPath: parentKey + '__' + fieldKey
50626
- },
50627
- data: fieldData,
50628
- };
49191
+ const EmailAggregateState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
50629
49192
  sink[fieldKey] = ingest$J(requestedField, EmailAggregateState);
50630
49193
  break;
50631
49194
  }
50632
49195
  case 'IDAggregate': {
50633
- const IDAggregateState = {
50634
- ...state,
50635
- path: {
50636
- parent: null,
50637
- propertyName: null,
50638
- fullPath: parentKey + '__' + fieldKey
50639
- },
50640
- data: fieldData,
50641
- };
49196
+ const IDAggregateState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
50642
49197
  sink[fieldKey] = ingest$z(requestedField, IDAggregateState);
50643
49198
  break;
50644
49199
  }
50645
49200
  case 'IntAggregate': {
50646
- const IntAggregateState = {
50647
- ...state,
50648
- path: {
50649
- parent: null,
50650
- propertyName: null,
50651
- fullPath: parentKey + '__' + fieldKey
50652
- },
50653
- data: fieldData,
50654
- };
49201
+ const IntAggregateState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
50655
49202
  sink[fieldKey] = ingest$u(requestedField, IntAggregateState);
50656
49203
  break;
50657
49204
  }
50658
49205
  case 'LatitudeAggregate': {
50659
- const LatitudeAggregateState = {
50660
- ...state,
50661
- path: {
50662
- parent: null,
50663
- propertyName: null,
50664
- fullPath: parentKey + '__' + fieldKey
50665
- },
50666
- data: fieldData,
50667
- };
49206
+ const LatitudeAggregateState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
50668
49207
  sink[fieldKey] = ingest$E(requestedField, LatitudeAggregateState);
50669
49208
  break;
50670
49209
  }
50671
49210
  case 'LongitudeAggregate': {
50672
- const LongitudeAggregateState = {
50673
- ...state,
50674
- path: {
50675
- parent: null,
50676
- propertyName: null,
50677
- fullPath: parentKey + '__' + fieldKey
50678
- },
50679
- data: fieldData,
50680
- };
49211
+ const LongitudeAggregateState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
50681
49212
  sink[fieldKey] = ingest$C(requestedField, LongitudeAggregateState);
50682
49213
  break;
50683
49214
  }
50684
49215
  case 'LongAggregate': {
50685
- const LongAggregateState = {
50686
- ...state,
50687
- path: {
50688
- parent: null,
50689
- propertyName: null,
50690
- fullPath: parentKey + '__' + fieldKey
50691
- },
50692
- data: fieldData,
50693
- };
49216
+ const LongAggregateState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
50694
49217
  sink[fieldKey] = ingest$R(requestedField, LongAggregateState);
50695
49218
  break;
50696
49219
  }
50697
49220
  case 'PercentAggregate': {
50698
- const PercentAggregateState = {
50699
- ...state,
50700
- path: {
50701
- parent: null,
50702
- propertyName: null,
50703
- fullPath: parentKey + '__' + fieldKey
50704
- },
50705
- data: fieldData,
50706
- };
49221
+ const PercentAggregateState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
50707
49222
  sink[fieldKey] = ingest$17(requestedField, PercentAggregateState);
50708
49223
  break;
50709
49224
  }
50710
49225
  case 'PhoneNumberAggregate': {
50711
- const PhoneNumberAggregateState = {
50712
- ...state,
50713
- path: {
50714
- parent: null,
50715
- propertyName: null,
50716
- fullPath: parentKey + '__' + fieldKey
50717
- },
50718
- data: fieldData,
50719
- };
49226
+ const PhoneNumberAggregateState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
50720
49227
  sink[fieldKey] = ingest$P(requestedField, PhoneNumberAggregateState);
50721
49228
  break;
50722
49229
  }
50723
49230
  case 'PicklistAggregate': {
50724
- const PicklistAggregateState = {
50725
- ...state,
50726
- path: {
50727
- parent: null,
50728
- propertyName: null,
50729
- fullPath: parentKey + '__' + fieldKey
50730
- },
50731
- data: fieldData,
50732
- };
49231
+ const PicklistAggregateState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
50733
49232
  sink[fieldKey] = ingest$v(requestedField, PicklistAggregateState);
50734
49233
  break;
50735
49234
  }
50736
49235
  case 'StringAggregate': {
50737
- const StringAggregateState = {
50738
- ...state,
50739
- path: {
50740
- parent: null,
50741
- propertyName: null,
50742
- fullPath: parentKey + '__' + fieldKey
50743
- },
50744
- data: fieldData,
50745
- };
49236
+ const StringAggregateState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
50746
49237
  sink[fieldKey] = ingest$14(requestedField, StringAggregateState);
50747
49238
  break;
50748
49239
  }
50749
49240
  case 'TextAreaAggregate': {
50750
- const TextAreaAggregateState = {
50751
- ...state,
50752
- path: {
50753
- parent: null,
50754
- propertyName: null,
50755
- fullPath: parentKey + '__' + fieldKey
50756
- },
50757
- data: fieldData,
50758
- };
49241
+ const TextAreaAggregateState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
50759
49242
  sink[fieldKey] = ingest$x(requestedField, TextAreaAggregateState);
50760
49243
  break;
50761
49244
  }
50762
49245
  case 'TimeAggregate': {
50763
- const TimeAggregateState = {
50764
- ...state,
50765
- path: {
50766
- parent: null,
50767
- propertyName: null,
50768
- fullPath: parentKey + '__' + fieldKey
50769
- },
50770
- data: fieldData,
50771
- };
49246
+ const TimeAggregateState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
50772
49247
  sink[fieldKey] = ingest$G(requestedField, TimeAggregateState);
50773
49248
  break;
50774
49249
  }
50775
49250
  case 'UrlAggregate': {
50776
- const UrlAggregateState = {
50777
- ...state,
50778
- path: {
50779
- parent: null,
50780
- propertyName: null,
50781
- fullPath: parentKey + '__' + fieldKey
50782
- },
50783
- data: fieldData,
50784
- };
49251
+ const UrlAggregateState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
50785
49252
  sink[fieldKey] = ingest$y(requestedField, UrlAggregateState);
50786
49253
  break;
50787
49254
  }
@@ -50906,15 +49373,7 @@ function getTypeCacheKeys$l(astNode, state) {
50906
49373
  const fieldKey = getSerializedKeyForField(requestedField, state.variables, fieldType);
50907
49374
  switch (fieldType.typename) {
50908
49375
  case 'RecordAggregate': {
50909
- const aggregateState = {
50910
- ...state,
50911
- path: {
50912
- parent: null,
50913
- propertyName: null,
50914
- fullPath: rootKey + '__' + fieldKey
50915
- },
50916
- data: fieldData,
50917
- };
49376
+ const aggregateState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
50918
49377
  cacheKeySink.merge(getTypeCacheKeys$m(requestedField, aggregateState));
50919
49378
  break;
50920
49379
  }
@@ -50953,15 +49412,7 @@ function ingestFieldByType$c(typename, parentKey, requestedField, sink, fieldKey
50953
49412
  break;
50954
49413
  }
50955
49414
  case 'RecordAggregate': {
50956
- const RecordAggregateState = {
50957
- ...state,
50958
- path: {
50959
- parent: null,
50960
- propertyName: null,
50961
- fullPath: parentKey + '__' + fieldKey
50962
- },
50963
- data: fieldData,
50964
- };
49415
+ const RecordAggregateState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
50965
49416
  sink[fieldKey] = ingest$l(requestedField, RecordAggregateState);
50966
49417
  break;
50967
49418
  }
@@ -51086,15 +49537,7 @@ function getTypeCacheKeys$k(astNode, state) {
51086
49537
  const fieldKey = getSerializedKeyForField(requestedField, state.variables, fieldType);
51087
49538
  switch (fieldType.typename) {
51088
49539
  case 'RecordResult': {
51089
- const nodeState = {
51090
- ...state,
51091
- path: {
51092
- parent: null,
51093
- propertyName: null,
51094
- fullPath: rootKey + '__' + fieldKey
51095
- },
51096
- data: fieldData,
51097
- };
49540
+ const nodeState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
51098
49541
  cacheKeySink.merge(getTypeCacheKeys$l(requestedField, nodeState));
51099
49542
  break;
51100
49543
  }
@@ -51139,15 +49582,7 @@ function ingestFieldByType$b(typename, parentKey, requestedField, sink, fieldKey
51139
49582
  break;
51140
49583
  }
51141
49584
  case 'RecordResult': {
51142
- const RecordResultState = {
51143
- ...state,
51144
- path: {
51145
- parent: null,
51146
- propertyName: null,
51147
- fullPath: parentKey + '__' + fieldKey
51148
- },
51149
- data: fieldData,
51150
- };
49585
+ const RecordResultState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
51151
49586
  sink[fieldKey] = ingest$k(requestedField, RecordResultState);
51152
49587
  break;
51153
49588
  }
@@ -51518,15 +49953,7 @@ function getTypeCacheKeys$i(astNode, state) {
51518
49953
  break;
51519
49954
  }
51520
49955
  case 'PageInfo': {
51521
- const pageInfoState = {
51522
- ...state,
51523
- path: {
51524
- parent: null,
51525
- propertyName: null,
51526
- fullPath: rootKey + '__' + fieldKey
51527
- },
51528
- data: fieldData,
51529
- };
49956
+ const pageInfoState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
51530
49957
  cacheKeySink.merge(getTypeCacheKeys$j(requestedField, pageInfoState));
51531
49958
  break;
51532
49959
  }
@@ -51577,28 +50004,12 @@ function ingestFieldByType$9(typename, parentKey, fullPathKey, requestedField, s
51577
50004
  break;
51578
50005
  }
51579
50006
  case 'RecordAggregateEdge': {
51580
- const RecordAggregateEdgeState = {
51581
- ...state,
51582
- path: {
51583
- parent: null,
51584
- propertyName: null,
51585
- fullPath: fullPathKey
51586
- },
51587
- data: fieldData,
51588
- };
50007
+ const RecordAggregateEdgeState = buildFieldState(state, fullPathKey, fieldData);
51589
50008
  sink[fieldKey] = ingest$j(requestedField, RecordAggregateEdgeState);
51590
50009
  break;
51591
50010
  }
51592
50011
  case 'PageInfo': {
51593
- const PageInfoState = {
51594
- ...state,
51595
- path: {
51596
- parent: null,
51597
- propertyName: null,
51598
- fullPath: fullPathKey
51599
- },
51600
- data: fieldData,
51601
- };
50012
+ const PageInfoState = buildFieldState(state, fullPathKey, fieldData);
51602
50013
  sink[fieldKey] = ingest$i(requestedField, PageInfoState);
51603
50014
  break;
51604
50015
  }
@@ -52064,15 +50475,7 @@ function getTypeCacheKeys$h(astNode, state) {
52064
50475
  const fieldKey = getSerializedKeyForField(requestedField, state.variables, fieldType);
52065
50476
  switch (fieldType.typename) {
52066
50477
  case 'RecordAggregateConnection': {
52067
- const recordQueryAggregateState = {
52068
- ...state,
52069
- path: {
52070
- parent: null,
52071
- propertyName: null,
52072
- fullPath: rootKey + '__' + fieldKey
52073
- },
52074
- data: fieldData,
52075
- };
50478
+ const recordQueryAggregateState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
52076
50479
  cacheKeySink.merge(getTypeCacheKeys$i(requestedField, recordQueryAggregateState));
52077
50480
  break;
52078
50481
  }
@@ -52093,15 +50496,7 @@ function ingestFieldByType$8(typename, parentKey, requestedField, sink, fieldKey
52093
50496
  break;
52094
50497
  }
52095
50498
  case 'RecordAggregateConnection': {
52096
- const RecordAggregateConnectionState = {
52097
- ...state,
52098
- path: {
52099
- parent: null,
52100
- propertyName: null,
52101
- fullPath: parentKey + '__' + fieldKey
52102
- },
52103
- data: fieldData,
52104
- };
50499
+ const RecordAggregateConnectionState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
52105
50500
  sink[fieldKey] = ingest$h(requestedField, RecordAggregateConnectionState);
52106
50501
  break;
52107
50502
  }
@@ -54376,405 +52771,157 @@ function getTypeCacheKeys$d(astNode, state) {
54376
52771
  const fieldKey = getSerializedKeyForField(requestedField, state.variables, fieldType);
54377
52772
  switch (fieldType.typename) {
54378
52773
  case 'IDValue': {
54379
- const LastModifiedByIdState = {
54380
- ...state,
54381
- path: {
54382
- parent: null,
54383
- propertyName: null,
54384
- fullPath: rootKey + '__' + fieldKey
54385
- },
54386
- data: fieldData,
54387
- };
52774
+ const LastModifiedByIdState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
54388
52775
  cacheKeySink.merge(getTypeCacheKeys$f(requestedField, LastModifiedByIdState));
54389
52776
  break;
54390
52777
  }
54391
52778
  case 'DateTimeValue': {
54392
- const LastModifiedDateState = {
54393
- ...state,
54394
- path: {
54395
- parent: null,
54396
- propertyName: null,
54397
- fullPath: rootKey + '__' + fieldKey
54398
- },
54399
- data: fieldData,
54400
- };
52779
+ const LastModifiedDateState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
54401
52780
  cacheKeySink.merge(getTypeCacheKeys$M(requestedField, LastModifiedDateState));
54402
52781
  break;
54403
52782
  }
54404
52783
  case 'DateTimeValue': {
54405
- const SystemModstampState = {
54406
- ...state,
54407
- path: {
54408
- parent: null,
54409
- propertyName: null,
54410
- fullPath: rootKey + '__' + fieldKey
54411
- },
54412
- data: fieldData,
54413
- };
52784
+ const SystemModstampState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
54414
52785
  cacheKeySink.merge(getTypeCacheKeys$M(requestedField, SystemModstampState));
54415
52786
  break;
54416
52787
  }
54417
52788
  case 'IDValue': {
54418
- const RecordTypeIdState = {
54419
- ...state,
54420
- path: {
54421
- parent: null,
54422
- propertyName: null,
54423
- fullPath: rootKey + '__' + fieldKey
54424
- },
54425
- data: fieldData,
54426
- };
52789
+ const RecordTypeIdState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
54427
52790
  cacheKeySink.merge(getTypeCacheKeys$f(requestedField, RecordTypeIdState));
54428
52791
  break;
54429
52792
  }
54430
52793
  case 'IntValue': {
54431
- const IntValueState = {
54432
- ...state,
54433
- path: {
54434
- parent: null,
54435
- propertyName: null,
54436
- fullPath: rootKey + '__' + fieldKey
54437
- },
54438
- data: fieldData,
54439
- };
52794
+ const IntValueState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
54440
52795
  cacheKeySink.merge(getTypeCacheKeys$17(requestedField, IntValueState));
54441
52796
  break;
54442
52797
  }
54443
52798
  case 'StringValue': {
54444
- const StringValueState = {
54445
- ...state,
54446
- path: {
54447
- parent: null,
54448
- propertyName: null,
54449
- fullPath: rootKey + '__' + fieldKey
54450
- },
54451
- data: fieldData,
54452
- };
52799
+ const StringValueState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
54453
52800
  cacheKeySink.merge(getTypeCacheKeys$16(requestedField, StringValueState));
54454
52801
  break;
54455
52802
  }
54456
52803
  case 'BooleanValue': {
54457
- const BooleanValueState = {
54458
- ...state,
54459
- path: {
54460
- parent: null,
54461
- propertyName: null,
54462
- fullPath: rootKey + '__' + fieldKey
54463
- },
54464
- data: fieldData,
54465
- };
52804
+ const BooleanValueState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
54466
52805
  cacheKeySink.merge(getTypeCacheKeys$10(requestedField, BooleanValueState));
54467
52806
  break;
54468
52807
  }
54469
52808
  case 'IDValue': {
54470
- const IDValueState = {
54471
- ...state,
54472
- path: {
54473
- parent: null,
54474
- propertyName: null,
54475
- fullPath: rootKey + '__' + fieldKey
54476
- },
54477
- data: fieldData,
54478
- };
52809
+ const IDValueState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
54479
52810
  cacheKeySink.merge(getTypeCacheKeys$f(requestedField, IDValueState));
54480
52811
  break;
54481
52812
  }
54482
52813
  case 'DateTimeValue': {
54483
- const DateTimeValueState = {
54484
- ...state,
54485
- path: {
54486
- parent: null,
54487
- propertyName: null,
54488
- fullPath: rootKey + '__' + fieldKey
54489
- },
54490
- data: fieldData,
54491
- };
52814
+ const DateTimeValueState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
54492
52815
  cacheKeySink.merge(getTypeCacheKeys$M(requestedField, DateTimeValueState));
54493
52816
  break;
54494
52817
  }
54495
52818
  case 'TimeValue': {
54496
- const TimeValueState = {
54497
- ...state,
54498
- path: {
54499
- parent: null,
54500
- propertyName: null,
54501
- fullPath: rootKey + '__' + fieldKey
54502
- },
54503
- data: fieldData,
54504
- };
52819
+ const TimeValueState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
54505
52820
  cacheKeySink.merge(getTypeCacheKeys$x(requestedField, TimeValueState));
54506
52821
  break;
54507
52822
  }
54508
52823
  case 'DateValue': {
54509
- const DateValueState = {
54510
- ...state,
54511
- path: {
54512
- parent: null,
54513
- propertyName: null,
54514
- fullPath: rootKey + '__' + fieldKey
54515
- },
54516
- data: fieldData,
54517
- };
52824
+ const DateValueState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
54518
52825
  cacheKeySink.merge(getTypeCacheKeys$13(requestedField, DateValueState));
54519
52826
  break;
54520
52827
  }
54521
52828
  case 'TextAreaValue': {
54522
- const TextAreaValueState = {
54523
- ...state,
54524
- path: {
54525
- parent: null,
54526
- propertyName: null,
54527
- fullPath: rootKey + '__' + fieldKey
54528
- },
54529
- data: fieldData,
54530
- };
52829
+ const TextAreaValueState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
54531
52830
  cacheKeySink.merge(getTypeCacheKeys$B(requestedField, TextAreaValueState));
54532
52831
  break;
54533
52832
  }
54534
52833
  case 'LongTextAreaValue': {
54535
- const LongTextAreaValueState = {
54536
- ...state,
54537
- path: {
54538
- parent: null,
54539
- propertyName: null,
54540
- fullPath: rootKey + '__' + fieldKey
54541
- },
54542
- data: fieldData,
54543
- };
52834
+ const LongTextAreaValueState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
54544
52835
  cacheKeySink.merge(getTypeCacheKeys$E(requestedField, LongTextAreaValueState));
54545
52836
  break;
54546
52837
  }
54547
52838
  case 'RichTextAreaValue': {
54548
- const RichTextAreaValueState = {
54549
- ...state,
54550
- path: {
54551
- parent: null,
54552
- propertyName: null,
54553
- fullPath: rootKey + '__' + fieldKey
54554
- },
54555
- data: fieldData,
54556
- };
52839
+ const RichTextAreaValueState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
54557
52840
  cacheKeySink.merge(getTypeCacheKeys$J(requestedField, RichTextAreaValueState));
54558
52841
  break;
54559
52842
  }
54560
52843
  case 'PhoneNumberValue': {
54561
- const PhoneNumberValueState = {
54562
- ...state,
54563
- path: {
54564
- parent: null,
54565
- propertyName: null,
54566
- fullPath: rootKey + '__' + fieldKey
54567
- },
54568
- data: fieldData,
54569
- };
52844
+ const PhoneNumberValueState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
54570
52845
  cacheKeySink.merge(getTypeCacheKeys$R(requestedField, PhoneNumberValueState));
54571
52846
  break;
54572
52847
  }
54573
52848
  case 'EmailValue': {
54574
- const EmailValueState = {
54575
- ...state,
54576
- path: {
54577
- parent: null,
54578
- propertyName: null,
54579
- fullPath: rootKey + '__' + fieldKey
54580
- },
54581
- data: fieldData,
54582
- };
52849
+ const EmailValueState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
54583
52850
  cacheKeySink.merge(getTypeCacheKeys$L(requestedField, EmailValueState));
54584
52851
  break;
54585
52852
  }
54586
52853
  case 'UrlValue': {
54587
- const UrlValueState = {
54588
- ...state,
54589
- path: {
54590
- parent: null,
54591
- propertyName: null,
54592
- fullPath: rootKey + '__' + fieldKey
54593
- },
54594
- data: fieldData,
54595
- };
52854
+ const UrlValueState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
54596
52855
  cacheKeySink.merge(getTypeCacheKeys$T(requestedField, UrlValueState));
54597
52856
  break;
54598
52857
  }
54599
52858
  case 'EncryptedStringValue': {
54600
- const EncryptedStringValueState = {
54601
- ...state,
54602
- path: {
54603
- parent: null,
54604
- propertyName: null,
54605
- fullPath: rootKey + '__' + fieldKey
54606
- },
54607
- data: fieldData,
54608
- };
52859
+ const EncryptedStringValueState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
54609
52860
  cacheKeySink.merge(getTypeCacheKeys$r(requestedField, EncryptedStringValueState));
54610
52861
  break;
54611
52862
  }
54612
52863
  case 'CurrencyValue': {
54613
- const CurrencyValueState = {
54614
- ...state,
54615
- path: {
54616
- parent: null,
54617
- propertyName: null,
54618
- fullPath: rootKey + '__' + fieldKey
54619
- },
54620
- data: fieldData,
54621
- };
52864
+ const CurrencyValueState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
54622
52865
  cacheKeySink.merge(getTypeCacheKeys$O(requestedField, CurrencyValueState));
54623
52866
  break;
54624
52867
  }
54625
52868
  case 'LongitudeValue': {
54626
- const LongitudeValueState = {
54627
- ...state,
54628
- path: {
54629
- parent: null,
54630
- propertyName: null,
54631
- fullPath: rootKey + '__' + fieldKey
54632
- },
54633
- data: fieldData,
54634
- };
52869
+ const LongitudeValueState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
54635
52870
  cacheKeySink.merge(getTypeCacheKeys$U(requestedField, LongitudeValueState));
54636
52871
  break;
54637
52872
  }
54638
52873
  case 'LatitudeValue': {
54639
- const LatitudeValueState = {
54640
- ...state,
54641
- path: {
54642
- parent: null,
54643
- propertyName: null,
54644
- fullPath: rootKey + '__' + fieldKey
54645
- },
54646
- data: fieldData,
54647
- };
52874
+ const LatitudeValueState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
54648
52875
  cacheKeySink.merge(getTypeCacheKeys$G(requestedField, LatitudeValueState));
54649
52876
  break;
54650
52877
  }
54651
52878
  case 'PicklistValue': {
54652
- const PicklistValueState = {
54653
- ...state,
54654
- path: {
54655
- parent: null,
54656
- propertyName: null,
54657
- fullPath: rootKey + '__' + fieldKey
54658
- },
54659
- data: fieldData,
54660
- };
52879
+ const PicklistValueState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
54661
52880
  cacheKeySink.merge(getTypeCacheKeys$P(requestedField, PicklistValueState));
54662
52881
  break;
54663
52882
  }
54664
52883
  case 'MultiPicklistValue': {
54665
- const MultiPicklistValueState = {
54666
- ...state,
54667
- path: {
54668
- parent: null,
54669
- propertyName: null,
54670
- fullPath: rootKey + '__' + fieldKey
54671
- },
54672
- data: fieldData,
54673
- };
52884
+ const MultiPicklistValueState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
54674
52885
  cacheKeySink.merge(getTypeCacheKeys$I(requestedField, MultiPicklistValueState));
54675
52886
  break;
54676
52887
  }
54677
52888
  case 'LongValue': {
54678
- const LongValueState = {
54679
- ...state,
54680
- path: {
54681
- parent: null,
54682
- propertyName: null,
54683
- fullPath: rootKey + '__' + fieldKey
54684
- },
54685
- data: fieldData,
54686
- };
52889
+ const LongValueState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
54687
52890
  cacheKeySink.merge(getTypeCacheKeys$1a(requestedField, LongValueState));
54688
52891
  break;
54689
52892
  }
54690
52893
  case 'DoubleValue': {
54691
- const DoubleValueState = {
54692
- ...state,
54693
- path: {
54694
- parent: null,
54695
- propertyName: null,
54696
- fullPath: rootKey + '__' + fieldKey
54697
- },
54698
- data: fieldData,
54699
- };
52894
+ const DoubleValueState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
54700
52895
  cacheKeySink.merge(getTypeCacheKeys$1b(requestedField, DoubleValueState));
54701
52896
  break;
54702
52897
  }
54703
52898
  case 'PercentValue': {
54704
- const PercentValueState = {
54705
- ...state,
54706
- path: {
54707
- parent: null,
54708
- propertyName: null,
54709
- fullPath: rootKey + '__' + fieldKey
54710
- },
54711
- data: fieldData,
54712
- };
52899
+ const PercentValueState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
54713
52900
  cacheKeySink.merge(getTypeCacheKeys$19(requestedField, PercentValueState));
54714
52901
  break;
54715
52902
  }
54716
52903
  case 'Base64Value': {
54717
- const Base64ValueState = {
54718
- ...state,
54719
- path: {
54720
- parent: null,
54721
- propertyName: null,
54722
- fullPath: rootKey + '__' + fieldKey
54723
- },
54724
- data: fieldData,
54725
- };
52904
+ const Base64ValueState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
54726
52905
  cacheKeySink.merge(getTypeCacheKeys$s(requestedField, Base64ValueState));
54727
52906
  break;
54728
52907
  }
54729
52908
  case 'JSONValue': {
54730
- const JSONValueState = {
54731
- ...state,
54732
- path: {
54733
- parent: null,
54734
- propertyName: null,
54735
- fullPath: rootKey + '__' + fieldKey
54736
- },
54737
- data: fieldData,
54738
- };
52909
+ const JSONValueState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
54739
52910
  cacheKeySink.merge(getTypeCacheKeys$u(requestedField, JSONValueState));
54740
52911
  break;
54741
52912
  }
54742
52913
  case 'RecordRepresentation': {
54743
- const parentRelationshipState = {
54744
- ...state,
54745
- path: {
54746
- parent: null,
54747
- propertyName: null,
54748
- fullPath: rootKey + '__' + fieldKey
54749
- },
54750
- data: fieldData,
54751
- };
52914
+ const parentRelationshipState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
54752
52915
  cacheKeySink.merge(getTypeCacheKeys$d(requestedField, parentRelationshipState));
54753
52916
  break;
54754
52917
  }
54755
52918
  case 'PolymorphicParentRelationship': {
54756
- const polymorphicParentRelationshipState = {
54757
- ...state,
54758
- path: {
54759
- parent: null,
54760
- propertyName: null,
54761
- fullPath: rootKey + '__' + fieldKey
54762
- },
54763
- data: fieldData,
54764
- };
52919
+ const polymorphicParentRelationshipState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
54765
52920
  cacheKeySink.merge(getTypeCacheKeys$n(requestedField, polymorphicParentRelationshipState));
54766
52921
  break;
54767
52922
  }
54768
52923
  case 'RecordConnection': {
54769
- const childRelationshipState = {
54770
- ...state,
54771
- path: {
54772
- parent: null,
54773
- propertyName: null,
54774
- fullPath: rootKey + '__' + fieldKey
54775
- },
54776
- data: fieldData,
54777
- };
52924
+ const childRelationshipState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
54778
52925
  cacheKeySink.merge(getTypeCacheKeys$e(requestedField, childRelationshipState));
54779
52926
  break;
54780
52927
  }
@@ -54804,353 +52951,137 @@ function ingestFieldByType$5(typename, parentKey, requestedField, sink, fieldKey
54804
52951
  break;
54805
52952
  }
54806
52953
  case 'IDValue': {
54807
- const IDValueState = {
54808
- ...state,
54809
- path: {
54810
- parent: null,
54811
- propertyName: null,
54812
- fullPath: parentKey + '__' + fieldKey
54813
- },
54814
- data: fieldData,
54815
- };
52954
+ const IDValueState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
54816
52955
  sink[fieldKey] = ingest$e(requestedField, IDValueState);
54817
52956
  break;
54818
52957
  }
54819
52958
  case 'DateTimeValue': {
54820
- const DateTimeValueState = {
54821
- ...state,
54822
- path: {
54823
- parent: null,
54824
- propertyName: null,
54825
- fullPath: parentKey + '__' + fieldKey
54826
- },
54827
- data: fieldData,
54828
- };
52959
+ const DateTimeValueState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
54829
52960
  sink[fieldKey] = ingest$L(requestedField, DateTimeValueState);
54830
52961
  break;
54831
52962
  }
54832
52963
  case 'IntValue': {
54833
- const IntValueState = {
54834
- ...state,
54835
- path: {
54836
- parent: null,
54837
- propertyName: null,
54838
- fullPath: parentKey + '__' + fieldKey
54839
- },
54840
- data: fieldData,
54841
- };
52964
+ const IntValueState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
54842
52965
  sink[fieldKey] = ingest$16(requestedField, IntValueState);
54843
52966
  break;
54844
52967
  }
54845
52968
  case 'StringValue': {
54846
- const StringValueState = {
54847
- ...state,
54848
- path: {
54849
- parent: null,
54850
- propertyName: null,
54851
- fullPath: parentKey + '__' + fieldKey
54852
- },
54853
- data: fieldData,
54854
- };
52969
+ const StringValueState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
54855
52970
  sink[fieldKey] = ingest$15(requestedField, StringValueState);
54856
52971
  break;
54857
52972
  }
54858
52973
  case 'BooleanValue': {
54859
- const BooleanValueState = {
54860
- ...state,
54861
- path: {
54862
- parent: null,
54863
- propertyName: null,
54864
- fullPath: parentKey + '__' + fieldKey
54865
- },
54866
- data: fieldData,
54867
- };
52974
+ const BooleanValueState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
54868
52975
  sink[fieldKey] = ingest$$(requestedField, BooleanValueState);
54869
52976
  break;
54870
52977
  }
54871
52978
  case 'TimeValue': {
54872
- const TimeValueState = {
54873
- ...state,
54874
- path: {
54875
- parent: null,
54876
- propertyName: null,
54877
- fullPath: parentKey + '__' + fieldKey
54878
- },
54879
- data: fieldData,
54880
- };
52979
+ const TimeValueState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
54881
52980
  sink[fieldKey] = ingest$w(requestedField, TimeValueState);
54882
52981
  break;
54883
52982
  }
54884
52983
  case 'DateValue': {
54885
- const DateValueState = {
54886
- ...state,
54887
- path: {
54888
- parent: null,
54889
- propertyName: null,
54890
- fullPath: parentKey + '__' + fieldKey
54891
- },
54892
- data: fieldData,
54893
- };
52984
+ const DateValueState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
54894
52985
  sink[fieldKey] = ingest$12(requestedField, DateValueState);
54895
52986
  break;
54896
52987
  }
54897
52988
  case 'TextAreaValue': {
54898
- const TextAreaValueState = {
54899
- ...state,
54900
- path: {
54901
- parent: null,
54902
- propertyName: null,
54903
- fullPath: parentKey + '__' + fieldKey
54904
- },
54905
- data: fieldData,
54906
- };
52989
+ const TextAreaValueState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
54907
52990
  sink[fieldKey] = ingest$A(requestedField, TextAreaValueState);
54908
52991
  break;
54909
52992
  }
54910
52993
  case 'LongTextAreaValue': {
54911
- const LongTextAreaValueState = {
54912
- ...state,
54913
- path: {
54914
- parent: null,
54915
- propertyName: null,
54916
- fullPath: parentKey + '__' + fieldKey
54917
- },
54918
- data: fieldData,
54919
- };
52994
+ const LongTextAreaValueState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
54920
52995
  sink[fieldKey] = ingest$D(requestedField, LongTextAreaValueState);
54921
52996
  break;
54922
52997
  }
54923
52998
  case 'RichTextAreaValue': {
54924
- const RichTextAreaValueState = {
54925
- ...state,
54926
- path: {
54927
- parent: null,
54928
- propertyName: null,
54929
- fullPath: parentKey + '__' + fieldKey
54930
- },
54931
- data: fieldData,
54932
- };
52999
+ const RichTextAreaValueState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
54933
53000
  sink[fieldKey] = ingest$I(requestedField, RichTextAreaValueState);
54934
53001
  break;
54935
53002
  }
54936
53003
  case 'PhoneNumberValue': {
54937
- const PhoneNumberValueState = {
54938
- ...state,
54939
- path: {
54940
- parent: null,
54941
- propertyName: null,
54942
- fullPath: parentKey + '__' + fieldKey
54943
- },
54944
- data: fieldData,
54945
- };
53004
+ const PhoneNumberValueState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
54946
53005
  sink[fieldKey] = ingest$Q(requestedField, PhoneNumberValueState);
54947
53006
  break;
54948
53007
  }
54949
53008
  case 'EmailValue': {
54950
- const EmailValueState = {
54951
- ...state,
54952
- path: {
54953
- parent: null,
54954
- propertyName: null,
54955
- fullPath: parentKey + '__' + fieldKey
54956
- },
54957
- data: fieldData,
54958
- };
53009
+ const EmailValueState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
54959
53010
  sink[fieldKey] = ingest$K(requestedField, EmailValueState);
54960
53011
  break;
54961
53012
  }
54962
53013
  case 'UrlValue': {
54963
- const UrlValueState = {
54964
- ...state,
54965
- path: {
54966
- parent: null,
54967
- propertyName: null,
54968
- fullPath: parentKey + '__' + fieldKey
54969
- },
54970
- data: fieldData,
54971
- };
53014
+ const UrlValueState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
54972
53015
  sink[fieldKey] = ingest$S(requestedField, UrlValueState);
54973
53016
  break;
54974
53017
  }
54975
53018
  case 'EncryptedStringValue': {
54976
- const EncryptedStringValueState = {
54977
- ...state,
54978
- path: {
54979
- parent: null,
54980
- propertyName: null,
54981
- fullPath: parentKey + '__' + fieldKey
54982
- },
54983
- data: fieldData,
54984
- };
53019
+ const EncryptedStringValueState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
54985
53020
  sink[fieldKey] = ingest$q(requestedField, EncryptedStringValueState);
54986
53021
  break;
54987
53022
  }
54988
53023
  case 'CurrencyValue': {
54989
- const CurrencyValueState = {
54990
- ...state,
54991
- path: {
54992
- parent: null,
54993
- propertyName: null,
54994
- fullPath: parentKey + '__' + fieldKey
54995
- },
54996
- data: fieldData,
54997
- };
53024
+ const CurrencyValueState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
54998
53025
  sink[fieldKey] = ingest$N(requestedField, CurrencyValueState);
54999
53026
  break;
55000
53027
  }
55001
53028
  case 'LongitudeValue': {
55002
- const LongitudeValueState = {
55003
- ...state,
55004
- path: {
55005
- parent: null,
55006
- propertyName: null,
55007
- fullPath: parentKey + '__' + fieldKey
55008
- },
55009
- data: fieldData,
55010
- };
53029
+ const LongitudeValueState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
55011
53030
  sink[fieldKey] = ingest$T(requestedField, LongitudeValueState);
55012
53031
  break;
55013
53032
  }
55014
53033
  case 'LatitudeValue': {
55015
- const LatitudeValueState = {
55016
- ...state,
55017
- path: {
55018
- parent: null,
55019
- propertyName: null,
55020
- fullPath: parentKey + '__' + fieldKey
55021
- },
55022
- data: fieldData,
55023
- };
53034
+ const LatitudeValueState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
55024
53035
  sink[fieldKey] = ingest$F(requestedField, LatitudeValueState);
55025
53036
  break;
55026
53037
  }
55027
53038
  case 'PicklistValue': {
55028
- const PicklistValueState = {
55029
- ...state,
55030
- path: {
55031
- parent: null,
55032
- propertyName: null,
55033
- fullPath: parentKey + '__' + fieldKey
55034
- },
55035
- data: fieldData,
55036
- };
53039
+ const PicklistValueState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
55037
53040
  sink[fieldKey] = ingest$O(requestedField, PicklistValueState);
55038
53041
  break;
55039
53042
  }
55040
53043
  case 'MultiPicklistValue': {
55041
- const MultiPicklistValueState = {
55042
- ...state,
55043
- path: {
55044
- parent: null,
55045
- propertyName: null,
55046
- fullPath: parentKey + '__' + fieldKey
55047
- },
55048
- data: fieldData,
55049
- };
53044
+ const MultiPicklistValueState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
55050
53045
  sink[fieldKey] = ingest$H(requestedField, MultiPicklistValueState);
55051
53046
  break;
55052
53047
  }
55053
53048
  case 'LongValue': {
55054
- const LongValueState = {
55055
- ...state,
55056
- path: {
55057
- parent: null,
55058
- propertyName: null,
55059
- fullPath: parentKey + '__' + fieldKey
55060
- },
55061
- data: fieldData,
55062
- };
53049
+ const LongValueState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
55063
53050
  sink[fieldKey] = ingest$19(requestedField, LongValueState);
55064
53051
  break;
55065
53052
  }
55066
53053
  case 'DoubleValue': {
55067
- const DoubleValueState = {
55068
- ...state,
55069
- path: {
55070
- parent: null,
55071
- propertyName: null,
55072
- fullPath: parentKey + '__' + fieldKey
55073
- },
55074
- data: fieldData,
55075
- };
53054
+ const DoubleValueState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
55076
53055
  sink[fieldKey] = ingest$1a(requestedField, DoubleValueState);
55077
53056
  break;
55078
53057
  }
55079
53058
  case 'PercentValue': {
55080
- const PercentValueState = {
55081
- ...state,
55082
- path: {
55083
- parent: null,
55084
- propertyName: null,
55085
- fullPath: parentKey + '__' + fieldKey
55086
- },
55087
- data: fieldData,
55088
- };
53059
+ const PercentValueState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
55089
53060
  sink[fieldKey] = ingest$18(requestedField, PercentValueState);
55090
53061
  break;
55091
53062
  }
55092
53063
  case 'Base64Value': {
55093
- const Base64ValueState = {
55094
- ...state,
55095
- path: {
55096
- parent: null,
55097
- propertyName: null,
55098
- fullPath: parentKey + '__' + fieldKey
55099
- },
55100
- data: fieldData,
55101
- };
53064
+ const Base64ValueState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
55102
53065
  sink[fieldKey] = ingest$r(requestedField, Base64ValueState);
55103
53066
  break;
55104
53067
  }
55105
53068
  case 'JSONValue': {
55106
- const JSONValueState = {
55107
- ...state,
55108
- path: {
55109
- parent: null,
55110
- propertyName: null,
55111
- fullPath: parentKey + '__' + fieldKey
55112
- },
55113
- data: fieldData,
55114
- };
53069
+ const JSONValueState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
55115
53070
  sink[fieldKey] = ingest$t(requestedField, JSONValueState);
55116
53071
  break;
55117
53072
  }
55118
53073
  case 'RecordRepresentation': {
55119
- const RecordRepresentationState = {
55120
- ...state,
55121
- path: {
55122
- parent: null,
55123
- propertyName: null,
55124
- fullPath: parentKey + '__' + fieldKey
55125
- },
55126
- data: fieldData,
55127
- };
53074
+ const RecordRepresentationState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
55128
53075
  sink[fieldKey] = ingest$d(requestedField, RecordRepresentationState);
55129
53076
  break;
55130
53077
  }
55131
53078
  case 'PolymorphicParentRelationship': {
55132
- const PolymorphicParentRelationshipState = {
55133
- ...state,
55134
- path: {
55135
- parent: null,
55136
- propertyName: null,
55137
- fullPath: parentKey + '__' + fieldKey
55138
- },
55139
- data: fieldData,
55140
- };
53079
+ const PolymorphicParentRelationshipState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
55141
53080
  sink[fieldKey] = ingest$m(requestedField, PolymorphicParentRelationshipState);
55142
53081
  break;
55143
53082
  }
55144
53083
  case 'RecordConnection': {
55145
- const RecordConnectionState = {
55146
- ...state,
55147
- path: {
55148
- parent: null,
55149
- propertyName: null,
55150
- fullPath: parentKey + '__' + fieldKey
55151
- },
55152
- data: fieldData,
55153
- };
53084
+ const RecordConnectionState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
55154
53085
  sink[fieldKey] = ingest$b(requestedField, RecordConnectionState);
55155
53086
  break;
55156
53087
  }
@@ -55269,15 +53200,7 @@ function getTypeCacheKeys$c(astNode, state) {
55269
53200
  const fieldKey = getSerializedKeyForField(requestedField, state.variables, fieldType);
55270
53201
  switch (fieldType.typename) {
55271
53202
  case 'RecordRepresentation': {
55272
- const nodeState = {
55273
- ...state,
55274
- path: {
55275
- parent: null,
55276
- propertyName: null,
55277
- fullPath: rootKey + '__' + fieldKey
55278
- },
55279
- data: fieldData,
55280
- };
53203
+ const nodeState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
55281
53204
  cacheKeySink.merge(getTypeCacheKeys$d(requestedField, nodeState));
55282
53205
  break;
55283
53206
  }
@@ -55322,15 +53245,7 @@ function ingestFieldByType$4(typename, parentKey, requestedField, sink, fieldKey
55322
53245
  break;
55323
53246
  }
55324
53247
  case 'RecordRepresentation': {
55325
- const RecordRepresentationState = {
55326
- ...state,
55327
- path: {
55328
- parent: null,
55329
- propertyName: null,
55330
- fullPath: parentKey + '__' + fieldKey
55331
- },
55332
- data: fieldData,
55333
- };
53248
+ const RecordRepresentationState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
55334
53249
  sink[fieldKey] = ingest$d(requestedField, RecordRepresentationState);
55335
53250
  break;
55336
53251
  }
@@ -55541,28 +53456,12 @@ function ingestFieldByType$3(typename, parentKey, fullPathKey, requestedField, s
55541
53456
  break;
55542
53457
  }
55543
53458
  case 'RecordEdge': {
55544
- const RecordEdgeState = {
55545
- ...state,
55546
- path: {
55547
- parent: null,
55548
- propertyName: null,
55549
- fullPath: fullPathKey
55550
- },
55551
- data: fieldData,
55552
- };
53459
+ const RecordEdgeState = buildFieldState(state, fullPathKey, fieldData);
55553
53460
  sink[fieldKey] = ingest$c(requestedField, RecordEdgeState);
55554
53461
  break;
55555
53462
  }
55556
53463
  case 'PageInfo': {
55557
- const PageInfoState = {
55558
- ...state,
55559
- path: {
55560
- parent: null,
55561
- propertyName: null,
55562
- fullPath: fullPathKey
55563
- },
55564
- data: fieldData,
55565
- };
53464
+ const PageInfoState = buildFieldState(state, fullPathKey, fieldData);
55566
53465
  sink[fieldKey] = ingest$i(requestedField, PageInfoState);
55567
53466
  break;
55568
53467
  }
@@ -55691,15 +53590,7 @@ function getTypeCacheKeys$b(astNode, state) {
55691
53590
  const fieldKey = getSerializedKeyForField(requestedField, state.variables, fieldType);
55692
53591
  switch (fieldType.typename) {
55693
53592
  case 'RecordConnection': {
55694
- const recordQueryState = {
55695
- ...state,
55696
- path: {
55697
- parent: null,
55698
- propertyName: null,
55699
- fullPath: rootKey + '__' + fieldKey
55700
- },
55701
- data: fieldData,
55702
- };
53593
+ const recordQueryState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
55703
53594
  cacheKeySink.merge(getTypeCacheKeys$e(requestedField, recordQueryState));
55704
53595
  break;
55705
53596
  }
@@ -55720,15 +53611,7 @@ function ingestFieldByType$2(typename, parentKey, requestedField, sink, fieldKey
55720
53611
  break;
55721
53612
  }
55722
53613
  case 'RecordConnection': {
55723
- const RecordConnectionState = {
55724
- ...state,
55725
- path: {
55726
- parent: null,
55727
- propertyName: null,
55728
- fullPath: parentKey + '__' + fieldKey
55729
- },
55730
- data: fieldData,
55731
- };
53614
+ const RecordConnectionState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
55732
53615
  sink[fieldKey] = ingest$b(requestedField, RecordConnectionState);
55733
53616
  break;
55734
53617
  }
@@ -55865,28 +53748,12 @@ function getTypeCacheKeys$a(astNode, state) {
55865
53748
  const fieldKey = getSerializedKeyForField(requestedField, state.variables, fieldType);
55866
53749
  switch (fieldType.typename) {
55867
53750
  case 'RecordQuery': {
55868
- const queryState = {
55869
- ...state,
55870
- path: {
55871
- parent: null,
55872
- propertyName: null,
55873
- fullPath: rootKey + '__' + fieldKey
55874
- },
55875
- data: fieldData,
55876
- };
53751
+ const queryState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
55877
53752
  cacheKeySink.merge(getTypeCacheKeys$b(requestedField, queryState));
55878
53753
  break;
55879
53754
  }
55880
53755
  case 'RecordQueryAggregate': {
55881
- const aggregateState = {
55882
- ...state,
55883
- path: {
55884
- parent: null,
55885
- propertyName: null,
55886
- fullPath: rootKey + '__' + fieldKey
55887
- },
55888
- data: fieldData,
55889
- };
53756
+ const aggregateState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
55890
53757
  cacheKeySink.merge(getTypeCacheKeys$h(requestedField, aggregateState));
55891
53758
  break;
55892
53759
  }
@@ -55908,15 +53775,7 @@ function getTypeCacheKeys$a(astNode, state) {
55908
53775
  break;
55909
53776
  }
55910
53777
  case 'RelatedListInfo': {
55911
- const relatedListByNameState = {
55912
- ...state,
55913
- path: {
55914
- parent: null,
55915
- propertyName: null,
55916
- fullPath: rootKey + '__' + fieldKey
55917
- },
55918
- data: fieldData,
55919
- };
53778
+ const relatedListByNameState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
55920
53779
  cacheKeySink.merge(getTypeCacheKeys$o(requestedField, relatedListByNameState));
55921
53780
  break;
55922
53781
  }
@@ -55973,54 +53832,22 @@ function ingestFieldByType$1(typename, parentKey, requestedField, sink, fieldKey
55973
53832
  break;
55974
53833
  }
55975
53834
  case 'RecordQuery': {
55976
- const RecordQueryState = {
55977
- ...state,
55978
- path: {
55979
- parent: null,
55980
- propertyName: null,
55981
- fullPath: parentKey + '__' + fieldKey
55982
- },
55983
- data: fieldData,
55984
- };
53835
+ const RecordQueryState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
55985
53836
  sink[fieldKey] = ingest$a(requestedField, RecordQueryState);
55986
53837
  break;
55987
53838
  }
55988
53839
  case 'RecordQueryAggregate': {
55989
- const RecordQueryAggregateState = {
55990
- ...state,
55991
- path: {
55992
- parent: null,
55993
- propertyName: null,
55994
- fullPath: parentKey + '__' + fieldKey
55995
- },
55996
- data: fieldData,
55997
- };
53840
+ const RecordQueryAggregateState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
55998
53841
  sink[fieldKey] = ingest$g(requestedField, RecordQueryAggregateState);
55999
53842
  break;
56000
53843
  }
56001
53844
  case 'ObjectInfo': {
56002
- const ObjectInfoState = {
56003
- ...state,
56004
- path: {
56005
- parent: null,
56006
- propertyName: null,
56007
- fullPath: parentKey + '__' + fieldKey
56008
- },
56009
- data: fieldData,
56010
- };
53845
+ const ObjectInfoState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
56011
53846
  sink[fieldKey] = ingest$V(requestedField, ObjectInfoState);
56012
53847
  break;
56013
53848
  }
56014
53849
  case 'RelatedListInfo': {
56015
- const RelatedListInfoState = {
56016
- ...state,
56017
- path: {
56018
- parent: null,
56019
- propertyName: null,
56020
- fullPath: parentKey + '__' + fieldKey
56021
- },
56022
- data: fieldData,
56023
- };
53850
+ const RelatedListInfoState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
56024
53851
  sink[fieldKey] = ingest$n(requestedField, RelatedListInfoState);
56025
53852
  break;
56026
53853
  }
@@ -56145,28 +53972,12 @@ function getTypeCacheKeys$9(astNode, state) {
56145
53972
  const fieldKey = getSerializedKeyForField(requestedField, state.variables, fieldType);
56146
53973
  switch (fieldType.typename) {
56147
53974
  case 'UIAPI': {
56148
- const uiapiState = {
56149
- ...state,
56150
- path: {
56151
- parent: null,
56152
- propertyName: null,
56153
- fullPath: rootKey + '__' + fieldKey
56154
- },
56155
- data: fieldData,
56156
- };
53975
+ const uiapiState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
56157
53976
  cacheKeySink.merge(getTypeCacheKeys$a(requestedField, uiapiState));
56158
53977
  break;
56159
53978
  }
56160
53979
  case 'RateLimit': {
56161
- const rateLimitState = {
56162
- ...state,
56163
- path: {
56164
- parent: null,
56165
- propertyName: null,
56166
- fullPath: rootKey + '__' + fieldKey
56167
- },
56168
- data: fieldData,
56169
- };
53980
+ const rateLimitState = buildFieldState(state, rootKey + '__' + fieldKey, fieldData);
56170
53981
  cacheKeySink.merge(getTypeCacheKeys$g(requestedField, rateLimitState));
56171
53982
  break;
56172
53983
  }
@@ -56211,28 +54022,12 @@ function ingestFieldByType(typename, parentKey, requestedField, sink, fieldKey,
56211
54022
  break;
56212
54023
  }
56213
54024
  case 'UIAPI': {
56214
- const UIAPIState = {
56215
- ...state,
56216
- path: {
56217
- parent: null,
56218
- propertyName: null,
56219
- fullPath: parentKey + '__' + fieldKey
56220
- },
56221
- data: fieldData,
56222
- };
54025
+ const UIAPIState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
56223
54026
  sink[fieldKey] = ingest$9(requestedField, UIAPIState);
56224
54027
  break;
56225
54028
  }
56226
54029
  case 'RateLimit': {
56227
- const RateLimitState = {
56228
- ...state,
56229
- path: {
56230
- parent: null,
56231
- propertyName: null,
56232
- fullPath: parentKey + '__' + fieldKey
56233
- },
56234
- data: fieldData,
56235
- };
54030
+ const RateLimitState = buildFieldState(state, parentKey + '__' + fieldKey, fieldData);
56236
54031
  sink[fieldKey] = ingest$f(requestedField, RateLimitState);
56237
54032
  break;
56238
54033
  }