ballerina-core 1.0.206 → 1.0.208

package/src/forms/domains/dispatched-forms/runner/domains/abstract-renderers/table/coroutines/builder.ts

@@ -0,0 +1,31 @@
+import {
+  CoTypedFactory,
+  TableAbstractRendererForeignMutationsExpected,
+} from "../../../../../../../../../main";
+import {
+  TableAbstractRendererReadonlyContext,
+  TableAbstractRendererState,
+  Unit,
+} from "../../../../../../../../../main";
+
+export const Co = <CustomPresentationContext = Unit, ExtraContext = Unit>() =>
+  CoTypedFactory<
+    TableAbstractRendererReadonlyContext<
+      CustomPresentationContext,
+      ExtraContext
+    >,
+    TableAbstractRendererState
+  >();
+
+export const InfiniteLoaderCo = <
+  CustomPresentationContext = Unit,
+  ExtraContext = Unit,
+>() =>
+  CoTypedFactory<
+    TableAbstractRendererReadonlyContext<
+      CustomPresentationContext,
+      ExtraContext
+    > &
+      Pick<TableAbstractRendererForeignMutationsExpected, "onChange">,
+    TableAbstractRendererState
+  >();

package/src/forms/domains/dispatched-forms/runner/domains/abstract-renderers/table/coroutines/infiniteLoader.ts

@@ -0,0 +1,84 @@
+import {
+  BaseFlags,
+  DispatchDelta,
+  DispatchParsedType,
+  DispatchTableApiSource,
+  Option,
+  PredicateValue,
+  TableAbstractRendererState,
+  unit,
+  Unit,
+  ValueOrErrors,
+  ValueTable,
+} from "../../../../../../../../../main";
+import { replaceWith } from "../../../../../../../../fun/domains/updater/domains/replaceWith/state";
+import { InfiniteLoaderCo as Co } from "./builder";
+import { Map } from "immutable";
+import { TableLoadWithRetries } from "./loadWithRetries";
+
+export const TableInfiniteLoader = <
+  CustomPresentationContext = Unit,
+  ExtraContext = Unit,
+>(
+  tableApiSource: DispatchTableApiSource,
+  fromTableApiParser: (value: unknown) => ValueOrErrors<PredicateValue, string>,
+) => {
+  return Co<CustomPresentationContext, ExtraContext>().Seq([
+    Co<CustomPresentationContext, ExtraContext>().SetState(
+      TableAbstractRendererState.Updaters.Core.customFormState.children.loadMore(
+        replaceWith<TableAbstractRendererState["customFormState"]["loadMore"]>(
+          "loading more",
+        ),
+      ),
+    ),
+    Co<CustomPresentationContext, ExtraContext>()
+      .GetState()
+      .then((current) =>
+        TableLoadWithRetries<CustomPresentationContext, ExtraContext>(
+          tableApiSource,
+          fromTableApiParser,
+        )(3)().then((res) =>
+          res.kind == "r"
+            ? Co<CustomPresentationContext, ExtraContext>().Seq([
+                Co<CustomPresentationContext, ExtraContext>().Do(() => {
+                  const updater = replaceWith<ValueTable>(
+                    ValueTable.Default.fromParsed(
+                      0,
+                      current.value.data.size + res.value.data.size, // validate this
+                      res.value.hasMoreValues,
+                      current.value.data.concat(res.value.data),
+                    ),
+                  );
+                  // Only needed as a delta is mandatory for onchange but it is ignored upstream
+                  const delta: DispatchDelta<BaseFlags> = {
+                    kind: "UnitReplace",
+                    replace: PredicateValue.Default.unit(),
+                    state: {},
+                    flags: {
+                      kind: "localOnly",
+                    },
+                    type: DispatchParsedType.Default.primitive("unit"),
+                    sourceAncestorLookupTypeNames:
+                      current.lookupTypeAncestorNames,
+                  };
+                  current.onChange(Option.Default.some(updater), delta);
+                }),
+                Co<CustomPresentationContext, ExtraContext>().SetState(
+                  TableAbstractRendererState.Updaters.Core.customFormState.children.loadMore(
+                    replaceWith<
+                      TableAbstractRendererState["customFormState"]["loadMore"]
+                    >("don't load more"),
+                  ),
+                ),
+              ])
+            : Co<CustomPresentationContext, ExtraContext>().SetState(
+                TableAbstractRendererState.Updaters.Core.customFormState.children.loadMore(
+                  replaceWith<
+                    TableAbstractRendererState["customFormState"]["loadMore"]
+                  >("error loading more"),
+                ),
+              ),
+        ),
+      ),
+  ]);
+};

package/src/forms/domains/dispatched-forms/runner/domains/abstract-renderers/table/coroutines/initialiseFiltersAndSorting.ts

@@ -0,0 +1,112 @@
+import { Map } from "immutable";
+import {
+  Coroutine,
+  DispatchParsedType,
+  DispatchTableApiSource,
+  DispatchTableFiltersAndSorting,
+  PredicateValue,
+  replaceWith,
+  Sum,
+  SumNType,
+  TableAbstractRendererReadonlyContext,
+  TableAbstractRendererState,
+  Unit,
+  ValueOrErrors,
+} from "../../../../../../../../../main";
+import { Co } from "./builder";
+
+export const InitialiseFiltersAndSorting = <
+  CustomPresentationContext = Unit,
+  ExtraContext = Unit,
+>(
+  tableApiSource: DispatchTableApiSource,
+  parseFromApiByType: (
+    type: DispatchParsedType<any>,
+  ) => (raw: any) => ValueOrErrors<PredicateValue, string>,
+  parseToApiByType: (
+    type: DispatchParsedType<any>,
+    value: PredicateValue,
+    state: any,
+  ) => ValueOrErrors<any, string>,
+  filterTypes: Map<string, SumNType<any>>,
+) => {
+  const getDefaultFiltersAndSortingWithRetries =
+    (maxRetries = 3) =>
+    (
+      attempt: number = 0,
+    ): Coroutine<
+      TableAbstractRendererReadonlyContext<
+        CustomPresentationContext,
+        ExtraContext
+      > &
+        TableAbstractRendererState,
+      TableAbstractRendererState,
+      Sum<"permanent error", DispatchTableFiltersAndSorting>
+    > =>
+      attempt < maxRetries
+        ? Co<CustomPresentationContext, ExtraContext>()
+            .Await(
+              tableApiSource.getDefaultFiltersAndSorting(filterTypes)(
+                parseFromApiByType,
+              ),
+              () =>
+                console.error(
+                  "error getting default filters and sorting from api",
+                ),
+            )
+            .then((filtersAndSorting) =>
+              filtersAndSorting.kind == "l"
+                ? Co<CustomPresentationContext, ExtraContext>().Return(
+                    Sum.Default.right(filtersAndSorting.value),
+                  )
+                : getDefaultFiltersAndSortingWithRetries(maxRetries)(
+                    attempt + 1,
+                  ),
+            )
+        : Co<CustomPresentationContext, ExtraContext>().Return(
+            Sum.Default.left("permanent error"),
+          );
+
+  return filterTypes.size == 0
+    ? Co<CustomPresentationContext, ExtraContext>().SetState(
+        TableAbstractRendererState.Updaters.Core.customFormState.children.isFilteringInitialized(
+          replaceWith<
+            TableAbstractRendererState["customFormState"]["isFilteringInitialized"]
+          >(true),
+        ),
+      )
+    : Co<CustomPresentationContext, ExtraContext>().Seq([
+        getDefaultFiltersAndSortingWithRetries()().then((filtersAndSorting) =>
+          filtersAndSorting.kind == "r"
+            ? Co<CustomPresentationContext, ExtraContext>().SetState(
+                TableAbstractRendererState.Updaters.Core.customFormState.children
+                  .filters(replaceWith(filtersAndSorting.value.filters))
+                  .then(
+                    TableAbstractRendererState.Updaters.Core.customFormState.children.sorting(
+                      replaceWith(filtersAndSorting.value.sorting),
+                    ),
+                  )
+                  .then(
+                    TableAbstractRendererState.Updaters.Core.customFormState.children.filterAndSortParam(
+                      replaceWith(
+                        TableAbstractRendererState.Operations.parseFiltersAndSortingToBase64String(
+                          filtersAndSorting.value.filters,
+                          filterTypes,
+                          filtersAndSorting.value.sorting,
+                          parseToApiByType,
+                          true,
+                        ),
+                      ),
+                    ),
+                  ),
+              ) // in case of permanent error, we don't want to block the flow, so just do nothing
+            : Co<CustomPresentationContext, ExtraContext>().Wait(0),
+        ),
+        Co<CustomPresentationContext, ExtraContext>().SetState(
+          TableAbstractRendererState.Updaters.Core.customFormState.children.isFilteringInitialized(
+            // always set to true even if the first call fails so we don't block the flow
+            replaceWith(true),
+          ),
+        ),
+      ]);
+};

package/src/forms/domains/dispatched-forms/runner/domains/abstract-renderers/table/coroutines/initialiseTable.ts

@@ -0,0 +1,89 @@
+import {
+  BaseFlags,
+  DispatchDelta,
+  DispatchParsedType,
+  DispatchTableApiSource,
+  Option,
+  PredicateValue,
+  TableAbstractRendererState,
+  unit,
+  Unit,
+  ValueOrErrors,
+  ValueTable,
+} from "../../../../../../../../../main";
+import { replaceWith } from "../../../../../../../../fun/domains/updater/domains/replaceWith/state";
+import { InfiniteLoaderCo as Co } from "./builder";
+import { TableLoadWithRetries } from "./loadWithRetries";
+
+export const InitialiseTable = <
+  CustomPresentationContext = Unit,
+  ExtraContext = Unit,
+>(
+  tableApiSource: DispatchTableApiSource,
+  fromTableApiParser: (value: unknown) => ValueOrErrors<PredicateValue, string>,
+) => {
+  return Co<CustomPresentationContext, ExtraContext>().Seq([
+    Co<CustomPresentationContext, ExtraContext>()
+      .GetState()
+      .then((current) =>
+        (current.value.data.size == 0 && current.value.hasMoreValues) ||
+        current.customFormState.loadingState == "reload from 0"
+          ? TableLoadWithRetries<CustomPresentationContext, ExtraContext>(
+              tableApiSource,
+              fromTableApiParser,
+            )(3)().then((res) =>
+              res.kind == "r"
+                ? Co<CustomPresentationContext, ExtraContext>().Seq([
+                    Co<CustomPresentationContext, ExtraContext>().Do(() => {
+                      const updater = replaceWith<ValueTable>(
+                        ValueTable.Default.fromParsed(
+                          0,
+                          res.value.data.size,
+                          res.value.hasMoreValues,
+                          res.value.data,
+                        ),
+                      );
+                      // Only needed as a delta is mandatory for onchange but it is ignored upstream
+                      const delta: DispatchDelta<BaseFlags> = {
+                        kind: "UnitReplace",
+                        replace: PredicateValue.Default.unit(),
+                        state: {},
+                        flags: {
+                          kind: "localOnly",
+                        },
+                        type: DispatchParsedType.Default.primitive("unit"),
+                        sourceAncestorLookupTypeNames:
+                          current.lookupTypeAncestorNames,
+                      };
+                      current.onChange(Option.Default.some(updater), delta);
+                      return Co<
+                        CustomPresentationContext,
+                        ExtraContext
+                      >().Return(unit);
+                    }),
+                    Co<CustomPresentationContext, ExtraContext>().SetState(
+                      TableAbstractRendererState.Updaters.Core.customFormState.children.loadingState(
+                        replaceWith<
+                          TableAbstractRendererState["customFormState"]["loadingState"]
+                        >("loaded"),
+                      ),
+                    ),
+                  ])
+                : Co<CustomPresentationContext, ExtraContext>().SetState(
+                    TableAbstractRendererState.Updaters.Core.customFormState.children.loadingState(
+                      replaceWith<
+                        TableAbstractRendererState["customFormState"]["loadingState"]
+                      >("error"),
+                    ),
+                  ),
+            )
+          : Co<CustomPresentationContext, ExtraContext>().SetState(
+              TableAbstractRendererState.Updaters.Core.customFormState.children.loadingState(
+                replaceWith<
+                  TableAbstractRendererState["customFormState"]["loadingState"]
+                >("loaded"),
+              ),
+            ),
+      ),
+  ]);
+};

package/src/forms/domains/dispatched-forms/runner/domains/abstract-renderers/table/coroutines/loadWithRetries.ts

@@ -0,0 +1,69 @@
+import {
+  Coroutine,
+  DispatchTableApiSource,
+  PredicateValue,
+  Sum,
+  TableAbstractRendererForeignMutationsExpected,
+  TableAbstractRendererReadonlyContext,
+  TableAbstractRendererState,
+  Unit,
+  ValueOrErrors,
+  ValueTable,
+} from "../../../../../../../../../main";
+import { InfiniteLoaderCo as Co } from "./builder";
+
+const DEFAULT_CHUNK_SIZE = 20;
+
+export const TableLoadWithRetries =
+  <CustomPresentationContext = Unit, ExtraContext = Unit>(
+    tableApiSource: DispatchTableApiSource,
+    fromTableApiParser: (
+      value: unknown,
+    ) => ValueOrErrors<PredicateValue, string>,
+  ) =>
+  (maxRetries = 3) =>
+  (
+    attempt: number = 0,
+  ): Coroutine<
+    TableAbstractRendererReadonlyContext<
+      CustomPresentationContext,
+      ExtraContext
+    > &
+      Pick<TableAbstractRendererForeignMutationsExpected, "onChange"> &
+      TableAbstractRendererState,
+    TableAbstractRendererState,
+    Sum<"permanent error", ValueTable>
+  > =>
+    attempt < maxRetries
+      ? Co<CustomPresentationContext, ExtraContext>()
+          .GetState()
+          .then((current) =>
+            Co<CustomPresentationContext, ExtraContext>().Await(
+              () =>
+                tableApiSource.getMany(fromTableApiParser)({
+                  chunkSize: DEFAULT_CHUNK_SIZE,
+                  from:
+                    current.customFormState.loadingState == "reload from 0"
+                      ? 0
+                      : current.value.data.size,
+                  filtersAndSorting:
+                    current.customFormState.filterAndSortParam === ""
+                      ? undefined
+                      : current.customFormState.filterAndSortParam,
+                }),
+              () => "error" as const,
+            ),
+          )
+          .then((apiResult) =>
+            apiResult.kind == "l"
+              ? Co<CustomPresentationContext, ExtraContext>().Return(
+                  Sum.Default.right(apiResult.value),
+                )
+              : TableLoadWithRetries<CustomPresentationContext, ExtraContext>(
+                  tableApiSource,
+                  fromTableApiParser,
+                )(maxRetries)(attempt + 1),
+          )
+      : Co<CustomPresentationContext, ExtraContext>().Return(
+          Sum.Default.left("permanent error"),
+        );

package/src/forms/domains/dispatched-forms/runner/domains/abstract-renderers/table/coroutines/runner.ts

@@ -1,179 +1,39 @@
 import { Map, Set } from "immutable";
+import { ValueInfiniteStreamState } from "../../../../../../../../value-infinite-data-stream/state";
 import {
-  ValueInfiniteStreamState,
-  ValueStreamPosition,
-} from "../../../../../../../../value-infinite-data-stream/state";
-import {
-  replaceWith,
+  DispatchParsedType,
+  DispatchTableApiSource,
+  PredicateValue,
   SumNType,
-  TableAbstractRendererState,
   Unit,
+  ValueOrErrors,
 } from "../../../../../../../../../main";
-import { TableAbstractRendererReadonlyContext } from "../../../../../../../../../main";
-import { CoTypedFactory } from "../../../../../../../../../main";
-
-const Co = <CustomPresentationContext = Unit, ExtraContext = Unit>() =>
-  CoTypedFactory<
-    TableAbstractRendererReadonlyContext<
-      CustomPresentationContext,
-      ExtraContext
-    >,
-    TableAbstractRendererState
-  >();
-
-// TODO -- very unsafe, needs work, checking undefined etc,,,
-const DEFAULT_CHUNK_SIZE = 20;
-const initialiseFiltersAndSorting = <
-  CustomPresentationContext = Unit,
-  ExtraContext = Unit,
->(
-  filterTypes: Map<string, SumNType<any>>,
-) => {
-  return filterTypes.size == 0
-    ? Co<CustomPresentationContext, ExtraContext>().SetState(
-        TableAbstractRendererState.Updaters.Core.customFormState.children.isFilteringInitialized(
-          // always set to true even if the first call fails so we don't block the flow
-          replaceWith(true),
-        ),
-      )
-    : Co<CustomPresentationContext, ExtraContext>().Seq([
-        Co<CustomPresentationContext, ExtraContext>()
-          .GetState()
-          .then((current) => {
-            const getDefaultFiltersAndSorting =
-              current.tableApiSource.getDefaultFiltersAndSorting(filterTypes);
-            return Co<CustomPresentationContext, ExtraContext>()
-              .Await(
-                getDefaultFiltersAndSorting(current.parseFromApiByType),
-                () =>
-                  console.error(
-                    "error getting default filters and sorting from api",
-                  ),
-              )
-              .then((filtersAndSorting) => {
-                return filtersAndSorting.kind == "l"
-                  ? Co<CustomPresentationContext, ExtraContext>().SetState(
-                      TableAbstractRendererState.Updaters.Core.customFormState.children
-                        .filters(replaceWith(filtersAndSorting.value.filters))
-                        .then(
-                          TableAbstractRendererState.Updaters.Core.customFormState.children.sorting(
-                            replaceWith(filtersAndSorting.value.sorting),
-                          ),
-                        ),
-                    )
-                  : Co<CustomPresentationContext, ExtraContext>().Wait(0);
-              });
-          }),
-        Co<CustomPresentationContext, ExtraContext>().SetState(
-          TableAbstractRendererState.Updaters.Core.customFormState.children.isFilteringInitialized(
-            // always set to true even if the first call fails so we don't block the flow
-            replaceWith(true),
-          ),
-        ),
-      ]);
-};
-
-const intialiseTable = <
-  CustomPresentationContext = Unit,
-  ExtraContext = Unit,
->() =>
-  Co<CustomPresentationContext, ExtraContext>()
-    .GetState()
-    .then((current) => {
-      if (current.value == undefined) {
-        return Co<CustomPresentationContext, ExtraContext>().Wait(0);
-      }
-      const initialData = current.value.data;
-      const hasMoreValues = current.value.hasMoreValues;
-      const from = current.value.from;
-      const to = current.value.to;
-      const getChunkWithParams = current.tableApiSource.getMany(
-        current.fromTableApiParser,
-      );
-
-      const params =
-        current.customFormState.filterAndSortParam == ""
-          ? Map<string, string>()
-          : Map([
-              ["filtersAndSorting", current.customFormState.filterAndSortParam],
-            ]);
-
-      return Co<CustomPresentationContext, ExtraContext>().SetState(
-        TableAbstractRendererState.Updaters.Core.customFormState.children
-          .stream(
-            replaceWith(
-              ValueInfiniteStreamState.Default(
-                DEFAULT_CHUNK_SIZE,
-                getChunkWithParams(params),
-                initialData.size == 0 && hasMoreValues ? "loadMore" : false,
-              ),
-            )
-              .then(
-                ValueInfiniteStreamState.Updaters.Coroutine.addLoadedChunk(0, {
-                  data: initialData,
-                  hasMoreValues: hasMoreValues,
-                  from,
-                  to,
-                }),
-              )
-              .then(
-                ValueInfiniteStreamState.Updaters.Core.position(
-                  ValueStreamPosition.Updaters.Core.nextStart(replaceWith(to)),
-                ),
-              ),
-          )
-          .thenMany([
-            TableAbstractRendererState.Updaters.Core.customFormState.children.rowStates(
-              replaceWith(Map()),
-            ),
-            TableAbstractRendererState.Updaters.Core.customFormState.children.selectedRows(
-              replaceWith(Set()),
-            ),
-            TableAbstractRendererState.Updaters.Core.customFormState.children.selectedDetailRow(
-              replaceWith(undefined as any),
-            ),
-            TableAbstractRendererState.Updaters.Core.customFormState.children.getChunkWithParams(
-              replaceWith(getChunkWithParams),
-            ),
-            TableAbstractRendererState.Updaters.Template.shouldReinitialize(
-              false,
-            ),
-            TableAbstractRendererState.Updaters.Core.customFormState.children.previousRemoteEntityVersionIdentifier(
-              replaceWith(current.remoteEntityVersionIdentifier),
-            ),
-            TableAbstractRendererState.Updaters.Core.customFormState.children.initializationStatus(
-              replaceWith<
-                TableAbstractRendererState["customFormState"]["initializationStatus"]
-              >("initialized"),
-            ),
-          ]),
-      );
-    });
-
-const reinitialise = <
-  CustomPresentationContext = Unit,
-  ExtraContext = Unit,
->() =>
-  Co<CustomPresentationContext, ExtraContext>()
-    .GetState()
-    .then((_) => {
-      return Co<CustomPresentationContext, ExtraContext>().SetState(
-        TableAbstractRendererState.Updaters.Core.customFormState.children.initializationStatus(
-          replaceWith<
-            TableAbstractRendererState["customFormState"]["initializationStatus"]
-          >("reinitializing"),
-        ),
-      );
-    });
+import { Co, InfiniteLoaderCo } from "./builder";
+import {} from "./initialiseFiltersAndSorting";
+import { InitialiseFiltersAndSorting } from "./initialiseFiltersAndSorting";
+import { TableInfiniteLoader } from "./infiniteLoader";
+import { InitialiseTable } from "./initialiseTable";
 
 export const TableInitialiseFiltersAndSortingRunner = <
   CustomPresentationContext = Unit,
   ExtraContext = Unit,
 >(
   filterTypes: Map<string, SumNType<any>>,
+  tableApiSource: DispatchTableApiSource,
+  parseFromApiByType: (
+    type: DispatchParsedType<any>,
+  ) => (raw: any) => ValueOrErrors<PredicateValue, string>,
+  parseToApiByType: (
+    type: DispatchParsedType<any>,
+    value: PredicateValue,
+    state: any,
+  ) => ValueOrErrors<any, string>,
 ) =>
   Co<CustomPresentationContext, ExtraContext>().Template<any>(
-    initialiseFiltersAndSorting<CustomPresentationContext, ExtraContext>(
+    InitialiseFiltersAndSorting<CustomPresentationContext, ExtraContext>(
+      tableApiSource,
+      parseFromApiByType,
+      parseToApiByType,
       filterTypes,
     ),
     {
@@ -182,37 +42,46 @@ export const TableInitialiseFiltersAndSortingRunner = <
         props.context.customFormState.isFilteringInitialized == false,
     },
   );
-export const TableReinitialiseRunner = <
+
+export const TableInitialiseTableRunner = <
   CustomPresentationContext = Unit,
   ExtraContext = Unit,
->() =>
-  Co<CustomPresentationContext, ExtraContext>().Template<any>(
-    reinitialise<CustomPresentationContext, ExtraContext>(),
+>(
+  tableApiSource: DispatchTableApiSource,
+  fromTableApiParser: (value: unknown) => ValueOrErrors<PredicateValue, string>,
+) =>
+  InfiniteLoaderCo<CustomPresentationContext, ExtraContext>().Template<any>(
+    InitialiseTable<CustomPresentationContext, ExtraContext>(
+      tableApiSource,
+      fromTableApiParser,
+    ),
     {
       interval: 15,
       runFilter: (props) =>
-        props.context.customFormState.initializationStatus === "initialized" &&
         props.context.customFormState.isFilteringInitialized &&
-        props.context.customFormState.shouldReinitialize,
+        (props.context.customFormState.loadingState == "loading" ||
+          props.context.customFormState.loadingState == "reload from 0"),
     },
   );
 
-export const TableRunner = <
+export const TableInfiniteLoaderRunner = <
   CustomPresentationContext = Unit,
   ExtraContext = Unit,
->() =>
-  Co<CustomPresentationContext, ExtraContext>().Template<any>(
-    intialiseTable<CustomPresentationContext, ExtraContext>(),
+>(
+  tableApiSource: DispatchTableApiSource,
+  fromTableApiParser: (value: unknown) => ValueOrErrors<PredicateValue, string>,
+) =>
+  InfiniteLoaderCo<CustomPresentationContext, ExtraContext>().Template<any>(
+    TableInfiniteLoader<CustomPresentationContext, ExtraContext>(
+      tableApiSource,
+      fromTableApiParser,
+    ),
     {
       interval: 15,
-      runFilter: (props) => {
-        return (
-          (props.context.customFormState.initializationStatus ===
-            "not initialized" ||
-            props.context.customFormState.initializationStatus ===
-              "reinitializing") &&
-          props.context.customFormState.isFilteringInitialized
-        );
-      },
+      runFilter: (props) =>
+        props.context.customFormState.isFilteringInitialized &&
+        props.context.customFormState.loadingState == "loaded" &&
+        (props.context.customFormState.loadMore == "load more" ||
+          props.context.customFormState.loadMore == "loading more"),
     },
   );