ballerina-core 1.0.256 → 1.0.258

package/bin/src/value-infinite-data-stream/state.js

@@ -3,95 +3,217 @@ import { Updater } from "../fun/domains/updater/state";
 import { replaceWith } from "../fun/domains/updater/domains/replaceWith/state";
 import { simpleUpdater } from "../fun/domains/updater/domains/simpleUpdater/state";
 import { AsyncState } from "../async/state";
-import { MapRepo, ValueOrErrors, ValueRecord, } from "../../main";
+import { MapRepo, ValueOrErrors, ValueRecord } from "../../main";
 export const ValueStreamPosition = {
-    Default: (initialChunkSize, shouldLoad = false) => ({
-        nextStart: 0,
-        chunkSize: initialChunkSize,
-        chunkIndex: 0,
-        shouldLoad,
-        lastModifiedTime: Date.now(),
-    }),
-    Updaters: {
-        Template: {
-            changeChunkSize: (chunkSize) => ValueStreamPosition.Updaters.Core.chunkSize(replaceWith(chunkSize)).then(ValueStreamPosition.Updaters.Template.reload()),
-            reload: () => ValueStreamPosition.Updaters.Core.lastModifiedTime(replaceWith(Date.now()))
-                .then(ValueStreamPosition.Updaters.Core.shouldLoad(replaceWith("reload")))
-                .then(ValueStreamPosition.Updaters.Core.chunkIndex(replaceWith(0))),
-            loadMore: () => ValueStreamPosition.Updaters.Core.chunkIndex((_) => _ + 1).then(ValueStreamPosition.Updaters.Core.lastModifiedTime(replaceWith(Date.now())).then(ValueStreamPosition.Updaters.Core.shouldLoad(replaceWith("loadMore")))),
-            initLoad: () => ValueStreamPosition.Updaters.Core.lastModifiedTime(replaceWith(Date.now())).then(ValueStreamPosition.Updaters.Core.shouldLoad(replaceWith("loadMore"))),
-        },
-        Core: Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, simpleUpdater()("lastModifiedTime")), simpleUpdater()("shouldLoad")), simpleUpdater()("chunkIndex")), simpleUpdater()("chunkSize")), simpleUpdater()("nextStart")),
-        Coroutine: {},
+  Default: (initialChunkSize, shouldLoad = false) => ({
+    nextStart: 0,
+    chunkSize: initialChunkSize,
+    chunkIndex: 0,
+    shouldLoad,
+    lastModifiedTime: Date.now(),
+  }),
+  Updaters: {
+    Template: {
+      changeChunkSize: (chunkSize) =>
+        ValueStreamPosition.Updaters.Core.chunkSize(
+          replaceWith(chunkSize),
+        ).then(ValueStreamPosition.Updaters.Template.reload()),
+      reload: () =>
+        ValueStreamPosition.Updaters.Core.lastModifiedTime(
+          replaceWith(Date.now()),
+        )
+          .then(
+            ValueStreamPosition.Updaters.Core.shouldLoad(replaceWith("reload")),
+          )
+          .then(ValueStreamPosition.Updaters.Core.chunkIndex(replaceWith(0))),
+      loadMore: () =>
+        ValueStreamPosition.Updaters.Core.chunkIndex((_) => _ + 1).then(
+          ValueStreamPosition.Updaters.Core.lastModifiedTime(
+            replaceWith(Date.now()),
+          ).then(
+            ValueStreamPosition.Updaters.Core.shouldLoad(
+              replaceWith("loadMore"),
+            ),
+          ),
+        ),
+      initLoad: () =>
+        ValueStreamPosition.Updaters.Core.lastModifiedTime(
+          replaceWith(Date.now()),
+        ).then(
+          ValueStreamPosition.Updaters.Core.shouldLoad(replaceWith("loadMore")),
+        ),
     },
+    Core: Object.assign(
+      Object.assign(
+        Object.assign(
+          Object.assign(
+            Object.assign({}, simpleUpdater()("lastModifiedTime")),
+            simpleUpdater()("shouldLoad"),
+          ),
+          simpleUpdater()("chunkIndex"),
+        ),
+        simpleUpdater()("chunkSize"),
+      ),
+      simpleUpdater()("nextStart"),
+    ),
+    Coroutine: {},
+  },
 };
 export const ValueChunk = {
-    Default: (hasMoreValues, data, from, to) => ({
-        hasMoreValues,
-        data,
-        from,
-        to,
-    }),
-    Updaters: {
-        Core: Object.assign(Object.assign(Object.assign(Object.assign({}, simpleUpdater()("hasMoreValues")), simpleUpdater()("data")), simpleUpdater()("from")), simpleUpdater()("to")),
-        Template: {
-            updateValue: (valueId, valueUpdater) => ValueChunk.Updaters.Core.data(MapRepo.Updaters.update(valueId, valueUpdater)),
-            updateValueItem: (valueId, itemId, valueUpdater) => ValueChunk.Updaters.Core.data(MapRepo.Updaters.update(valueId, ValueRecord.Updaters.update(itemId, valueUpdater))),
-        },
+  Default: (hasMoreValues, data, from, to) => ({
+    hasMoreValues,
+    data,
+    from,
+    to,
+  }),
+  Updaters: {
+    Core: Object.assign(
+      Object.assign(
+        Object.assign(
+          Object.assign({}, simpleUpdater()("hasMoreValues")),
+          simpleUpdater()("data"),
+        ),
+        simpleUpdater()("from"),
+      ),
+      simpleUpdater()("to"),
+    ),
+    Template: {
+      updateValue: (valueId, valueUpdater) =>
+        ValueChunk.Updaters.Core.data(
+          MapRepo.Updaters.update(valueId, valueUpdater),
+        ),
+      updateValueItem: (valueId, itemId, valueUpdater) =>
+        ValueChunk.Updaters.Core.data(
+          MapRepo.Updaters.update(
+            valueId,
+            ValueRecord.Updaters.update(itemId, valueUpdater),
+          ),
+        ),
     },
+  },
 };
 export const StateChunkItem = {
-    Default: (state) => Map(state),
+  Default: (state) => Map(state),
 };
 export const StateChunk = {
-    Default: (state) => Map(state),
+  Default: (state) => Map(state),
 };
 export const ValueInfiniteStreamState = {
-    Default: (initialChunkSize, getChunk, shouldLoad) => ({
-        loadingMore: AsyncState.Default.unloaded(),
-        loadedElements: OrderedMap(),
-        position: ValueStreamPosition.Default(initialChunkSize, shouldLoad),
-        getChunk,
-    }),
-    Operations: {
-        shouldCoroutineRun: (current) => current.position.shouldLoad != false,
-        loadNextPage: (current) => {
-            var _a;
-            return current.position.shouldLoad !== false &&
-                ((_a = current.loadedElements.last()) === null || _a === void 0 ? void 0 : _a.hasMoreValues) !== false;
-        },
-        getChunkIndexForValue: (current, valueId) => ValueOrErrors.Default.return(current.loadedElements.findLastKey((chunk) => chunk.data.has(valueId))).Then((chunkIndex) => chunkIndex == undefined
-            ? ValueOrErrors.Default.throwOne("value not found in any chunks")
-            : ValueOrErrors.Default.return(chunkIndex)),
+  Default: (initialChunkSize, getChunk, shouldLoad) => ({
+    loadingMore: AsyncState.Default.unloaded(),
+    loadedElements: OrderedMap(),
+    position: ValueStreamPosition.Default(initialChunkSize, shouldLoad),
+    getChunk,
+  }),
+  Operations: {
+    shouldCoroutineRun: (current) => current.position.shouldLoad != false,
+    loadNextPage: (current) => {
+      var _a;
+      return (
+        current.position.shouldLoad !== false &&
+        ((_a = current.loadedElements.last()) === null || _a === void 0
+          ? void 0
+          : _a.hasMoreValues) !== false
+      );
     },
-    Updaters: {
-        Coroutine: {
-            addLoadedChunk: (chunkIndex, newChunk) => ValueInfiniteStreamState.Updaters.Core.loadedElements((_) => _.set(chunkIndex, newChunk)),
-        },
-        Core: Object.assign(Object.assign(Object.assign(Object.assign({}, simpleUpdater()("getChunk")), simpleUpdater()("loadingMore")), simpleUpdater()("loadedElements")), { whenNotAlreadyLoading: (_) => {
-                return Updater((current) => {
-                    if (ValueInfiniteStreamState.Operations.loadNextPage(current)) {
-                        return current;
-                    }
-                    return _(current);
-                });
-            }, position: (positionUpdater) => Updater((current) => {
-                const newPosition = positionUpdater(current.position);
-                let newState = current;
-                if (newPosition.chunkSize != current.position.chunkSize)
-                    newState =
-                        ValueInfiniteStreamState.Updaters.Core.clearLoadedElements()(newState);
-                return Object.assign(Object.assign({}, newState), { position: newPosition });
-            }), clearLoadedElements: () => ValueInfiniteStreamState.Updaters.Core.loadedElements((_) => OrderedMap()) }),
-        Template: {
-            reload: (getChunk) => ValueInfiniteStreamState.Updaters.Core.position(ValueStreamPosition.Updaters.Template.reload())
-                .then(ValueInfiniteStreamState.Updaters.Core.clearLoadedElements())
-                .then(ValueInfiniteStreamState.Updaters.Core.getChunk(replaceWith(getChunk))),
-            loadMore: () => ValueInfiniteStreamState.Updaters.Core.whenNotAlreadyLoading(ValueInfiniteStreamState.Updaters.Core.position(ValueStreamPosition.Updaters.Template.loadMore())),
-            initLoad: () => ValueInfiniteStreamState.Updaters.Core.whenNotAlreadyLoading(ValueInfiniteStreamState.Updaters.Core.position(ValueStreamPosition.Updaters.Template.initLoad())),
-            updateChunkValue: (chunkIndex, chunkValueKey) => (valueUpdater) => ValueInfiniteStreamState.Updaters.Core.loadedElements(MapRepo.Updaters.update(chunkIndex, ValueChunk.Updaters.Template.updateValue(chunkValueKey, valueUpdater))),
-            updateChunkValueItem: (chunkIndex, chunkValueKey, chunkValueItemKey) => (valueUpdater) => ValueInfiniteStreamState.Updaters.Core.loadedElements(MapRepo.Updaters.update(chunkIndex, ValueChunk.Updaters.Template.updateValueItem(chunkValueKey, chunkValueItemKey, valueUpdater))),
+    getChunkIndexForValue: (current, valueId) =>
+      ValueOrErrors.Default.return(
+        current.loadedElements.findLastKey((chunk) => chunk.data.has(valueId)),
+      ).Then((chunkIndex) =>
+        chunkIndex == undefined
+          ? ValueOrErrors.Default.throwOne("value not found in any chunks")
+          : ValueOrErrors.Default.return(chunkIndex),
+      ),
+  },
+  Updaters: {
+    Coroutine: {
+      addLoadedChunk: (chunkIndex, newChunk) =>
+        ValueInfiniteStreamState.Updaters.Core.loadedElements((_) =>
+          _.set(chunkIndex, newChunk),
+        ),
+    },
+    Core: Object.assign(
+      Object.assign(
+        Object.assign(
+          Object.assign({}, simpleUpdater()("getChunk")),
+          simpleUpdater()("loadingMore"),
+        ),
+        simpleUpdater()("loadedElements"),
+      ),
+      {
+        whenNotAlreadyLoading: (_) => {
+          return Updater((current) => {
+            if (ValueInfiniteStreamState.Operations.loadNextPage(current)) {
+              return current;
+            }
+            return _(current);
+          });
         },
+        position: (positionUpdater) =>
+          Updater((current) => {
+            const newPosition = positionUpdater(current.position);
+            let newState = current;
+            if (newPosition.chunkSize != current.position.chunkSize)
+              newState =
+                ValueInfiniteStreamState.Updaters.Core.clearLoadedElements()(
+                  newState,
+                );
+            return Object.assign(Object.assign({}, newState), {
+              position: newPosition,
+            });
+          }),
+        clearLoadedElements: () =>
+          ValueInfiniteStreamState.Updaters.Core.loadedElements((_) =>
+            OrderedMap(),
+          ),
+      },
+    ),
+    Template: {
+      reload: (getChunk) =>
+        ValueInfiniteStreamState.Updaters.Core.position(
+          ValueStreamPosition.Updaters.Template.reload(),
+        )
+          .then(ValueInfiniteStreamState.Updaters.Core.clearLoadedElements())
+          .then(
+            ValueInfiniteStreamState.Updaters.Core.getChunk(
+              replaceWith(getChunk),
+            ),
+          ),
+      loadMore: () =>
+        ValueInfiniteStreamState.Updaters.Core.whenNotAlreadyLoading(
+          ValueInfiniteStreamState.Updaters.Core.position(
+            ValueStreamPosition.Updaters.Template.loadMore(),
+          ),
+        ),
+      initLoad: () =>
+        ValueInfiniteStreamState.Updaters.Core.whenNotAlreadyLoading(
+          ValueInfiniteStreamState.Updaters.Core.position(
+            ValueStreamPosition.Updaters.Template.initLoad(),
+          ),
+        ),
+      updateChunkValue: (chunkIndex, chunkValueKey) => (valueUpdater) =>
+        ValueInfiniteStreamState.Updaters.Core.loadedElements(
+          MapRepo.Updaters.update(
+            chunkIndex,
+            ValueChunk.Updaters.Template.updateValue(
+              chunkValueKey,
+              valueUpdater,
+            ),
+          ),
+        ),
+      updateChunkValueItem:
+        (chunkIndex, chunkValueKey, chunkValueItemKey) => (valueUpdater) =>
+          ValueInfiniteStreamState.Updaters.Core.loadedElements(
+            MapRepo.Updaters.update(
+              chunkIndex,
+              ValueChunk.Updaters.Template.updateValueItem(
+                chunkValueKey,
+                chunkValueItemKey,
+                valueUpdater,
+              ),
+            ),
+          ),
     },
+  },
 };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/bin/src/value-infinite-data-stream/template.js

@@ -1,5 +1,7 @@
 import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
 import { Template } from "../template/state";
 import { ValueStreamDataLoader } from "./coroutines/runner";
-export const ValueInfiniteStreamTemplate = Template.Default((_props) => _jsx(_Fragment, {})).any([ValueStreamDataLoader()]);
-//# sourceMappingURL=template.js.map
+export const ValueInfiniteStreamTemplate = Template.Default((_props) =>
+  _jsx(_Fragment, {}),
+).any([ValueStreamDataLoader()]);
+//# sourceMappingURL=template.js.map

package/bin/src/visibility/state.d.ts

@@ -1,2 +1,5 @@
-export type Visibility = "fully-visible" | "fully-invisible" | "partially-visible";
-//# sourceMappingURL=state.d.ts.map
+export type Visibility =
+  | "fully-visible"
+  | "fully-invisible"
+  | "partially-visible";
+//# sourceMappingURL=state.d.ts.map

package/bin/src/visibility/state.js

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/main.ts

@@ -141,6 +141,7 @@ export * from "./src/forms/domains/dispatched-forms/deserializer/domains/specifi
 export * from "./src/forms/domains/dispatched-forms/deserializer/template";
 export * from "./src/forms/domains/dispatched-forms/deserializer/coroutines/runner";
 export * from "./src/forms/domains/dispatched-forms/deserializer/state";
+export * from "./src/forms/domains/dispatched-forms/deserializer/domains/specification/domains/serializable/state";
 export * from "./src/forms/domains/dispatched-forms/runner/domains/deltas/state";
 export * from "./src/forms/domains/dispatched-forms/runner/domains/abstract-renderers/base-64-file/template";
 export * from "./src/forms/domains/dispatched-forms/runner/domains/abstract-renderers/boolean/template";

package/package.json

@@ -2,7 +2,7 @@
   "name": "ballerina-core",
   "author": "Dr. Giuseppe Maggiore",
   "private": false,
-  "version": "1.0.256",
+  "version": "1.0.258",
   "main": "main.ts",
   "scripts": {
     "prettier": "prettier --write ."

package/src/forms/domains/dispatched-forms/deserializer/coroutines/runner.ts

@@ -4,9 +4,9 @@ import {
   Sum,
   Synchronize,
   Unit,
-  Specification,
   ValueOrErrors,
   DispatchInjectablesTypes,
+  Specification,
 } from "../../../../../../main";
 import { CoTypedFactory } from "../../../../../coroutines/builder";
 import {
@@ -80,7 +80,7 @@ export const LoadAndDeserializeSpecification = <
             current.fieldTypeConverters,
             current.concreteRenderers,
             injectedPrimitives,
-          )(serializedSpecifications);
+          )(serializedSpecifications, current.desiredLaunchers);
 
           if (deserializationResult.kind == "errors") {
             console.error(

package/src/forms/domains/dispatched-forms/deserializer/domains/specification/domains/apis/state.ts

@@ -45,8 +45,8 @@ export const EnumApis = {
   Operations: {
     Deserialize: (
       serializedApiEnums?: unknown,
-    ): ValueOrErrors<undefined | EnumApis, string> =>
-      serializedApiEnums === undefined
+    ): ValueOrErrors<undefined | EnumApis, string> => {
+      return serializedApiEnums === undefined
         ? ValueOrErrors.Default.return(undefined)
         : !isObject(serializedApiEnums)
           ? ValueOrErrors.Default.throwOne(
@@ -72,7 +72,8 @@ export const EnumApis = {
                 errors.map(
                   (error) => `${error}\n...When deserializing enum apis`,
                 ),
-              ),
+              );
+    },
   },
 };
 
@@ -82,8 +83,8 @@ export const StreamApis = {
   Operations: {
     Deserialize: (
       serializedApiStreams?: unknown,
-    ): ValueOrErrors<undefined | StreamApis, string> =>
-      serializedApiStreams === undefined
+    ): ValueOrErrors<undefined | StreamApis, string> => {
+      return serializedApiStreams === undefined
         ? ValueOrErrors.Default.return(undefined)
         : !isObject(serializedApiStreams)
           ? ValueOrErrors.Default.throwOne(
@@ -109,7 +110,8 @@ export const StreamApis = {
                 errors.map(
                   (error) => `${error}\n...When deserializing stream apis`,
                 ),
-              ),
+              );
+    },
   },
 };
 
@@ -199,6 +201,7 @@ export const TableApis = {
         ExtraContext
       >,
       types: Map<DispatchTypeName, DispatchParsedType<T>>,
+      serializedTypes: Record<string, SerializedType<T>>,
       serializedFiltering?: unknown,
       injectedPrimitives?: DispatchInjectedPrimitives<T>,
     ): ValueOrErrors<undefined | TableApiFiltering<T>, string> => {
@@ -249,11 +252,8 @@ export const TableApis = {
                                 : DispatchParsedType.Operations.ParseRawType(
                                     "filter",
                                     value.type as SerializedType<T>,
-                                    Set(types.keys()),
-                                    {},
-                                    types.map((t) =>
-                                      ValueOrErrors.Default.return(t),
-                                    ),
+                                    serializedTypes,
+                                    Map(),
                                     injectedPrimitives,
                                   ).Then((type) =>
                                     Renderer.Operations.Deserialize(
@@ -269,7 +269,9 @@ export const TableApis = {
                                       concreteRenderers,
                                       types,
                                       undefined,
-                                    ).Then((renderer) =>
+                                      {},
+                                      Map(),
+                                    ).Then(([renderer, _]) =>
                                       ValueOrErrors.Operations.All<
                                         FilterType<T>,
                                         string
@@ -348,110 +350,113 @@ export const TableApis = {
         ExtraContext
       >,
       types: Map<DispatchTypeName, DispatchParsedType<T>>,
+      serializedTypes: Record<string, SerializedType<T>>,
       serializedApiTables?: unknown,
       injectedPrimitives?: DispatchInjectedPrimitives<T>,
-    ): ValueOrErrors<undefined | TableApis<T>, string> =>
-      serializedApiTables === undefined
-        ? ValueOrErrors.Default.return(undefined)
-        : !TableApis.Operations.IsValidTables(serializedApiTables)
-          ? ValueOrErrors.Default.throwOne(
-              `serializedApiTables is not a valid tables api object`,
-            )
-          : ValueOrErrors.Operations.All(
-              List<
-                ValueOrErrors<
-                  [
-                    TableApiName,
-                    {
-                      type: DispatchTypeName;
-                      methods: Array<TableMethod>;
-                      highlightedFilters?: List<ColumnName>;
-                      filtering?: TableApiFiltering<T>;
-                    },
-                  ],
-                  string
-                >
-              >(
-                Object.entries(serializedApiTables).map(([key, value]) =>
-                  !TableApis.Operations.IsValidTableApi(value)
-                    ? ValueOrErrors.Default.throwOne(
-                        `${key} is not a valid table api object`,
-                      )
-                    : TableApis.Operations.DeserializeFiltering(
-                        concreteRenderers,
-                        types,
-                        value.filtering,
-                        injectedPrimitives,
-                      ).Then((filtering) => {
-                        if (typeof value.type !== "string") {
-                          return ValueOrErrors.Default.throwOne(
-                            `type is not a string`,
-                          );
-                        }
+    ): ValueOrErrors<undefined | TableApis<T>, string> => {
+      if (serializedApiTables === undefined) {
+        return ValueOrErrors.Default.return(undefined);
+      }
 
-                        const finalMethods = value.methods ?? [];
-                        const finalSorting = value.sorting ?? [];
+      const isValidTables =
+        TableApis.Operations.IsValidTables(serializedApiTables);
+      if (!isValidTables) {
+        return ValueOrErrors.Default.throwOne(
+          `serializedApiTables is not a valid tables api object`,
+        );
+      }
 
-                        if (
-                          !TableApis.Operations.IsValidSorting(finalSorting)
-                        ) {
-                          return ValueOrErrors.Default.throwOne(
-                            `sorting is not an array of strings`,
-                          );
-                        }
+      return ValueOrErrors.Operations.All(
+        List<
+          ValueOrErrors<
+            [
+              TableApiName,
+              {
+                type: DispatchTypeName;
+                methods: Array<TableMethod>;
+                highlightedFilters?: List<ColumnName>;
+                filtering?: TableApiFiltering<T>;
+              },
+            ],
+            string
+          >
+        >(
+          Object.entries(serializedApiTables).map(([key, value], index) =>
+            !TableApis.Operations.IsValidTableApi(value)
+              ? ValueOrErrors.Default.throwOne(
+                  `${key} is not a valid table api object`,
+                )
+              : TableApis.Operations.DeserializeFiltering(
+                  concreteRenderers,
+                  types,
+                  serializedTypes,
+                  value.filtering,
+                  injectedPrimitives,
+                ).Then((filtering) => {
+                  if (typeof value.type !== "string") {
+                    return ValueOrErrors.Default.throwOne(
+                      `type is not a string`,
+                    );
+                  }
 
-                        if (
-                          !TableApis.Operations.IsMethodsArray(finalMethods)
-                        ) {
-                          return ValueOrErrors.Default.throwOne(
-                            `methods is not an array of valid table methods`,
-                          );
-                        }
+                  const finalMethods = value.methods ?? [];
+                  const finalSorting = value.sorting ?? [];
 
-                        if (
-                          !TableApis.Operations.IsValidHighlightedFilters(
-                            value.highlightedFilters,
-                          )
-                        ) {
-                          return ValueOrErrors.Default.throwOne(
-                            `highlightedFilters is not an array of strings`,
-                          );
-                        }
+                  if (!TableApis.Operations.IsValidSorting(finalSorting)) {
+                    return ValueOrErrors.Default.throwOne(
+                      `sorting is not an array of strings`,
+                    );
+                  }
 
-                        return ValueOrErrors.Default.return([
-                          key,
-                          {
-                            type: value.type,
-                            methods: finalMethods,
-                            highlightedFilters: value.highlightedFilters
-                              ? List(value.highlightedFilters)
-                              : undefined,
-                            filtering,
-                            sorting: finalSorting,
-                          },
-                        ]);
-                      }),
-                ),
-              ),
-            )
-              .Then((entries) =>
-                ValueOrErrors.Default.return(
-                  Map<
-                    TableApiName,
+                  if (!TableApis.Operations.IsMethodsArray(finalMethods)) {
+                    return ValueOrErrors.Default.throwOne(
+                      `methods is not an array of valid table methods`,
+                    );
+                  }
+
+                  if (
+                    !TableApis.Operations.IsValidHighlightedFilters(
+                      value.highlightedFilters,
+                    )
+                  ) {
+                    return ValueOrErrors.Default.throwOne(
+                      `highlightedFilters is not an array of strings`,
+                    );
+                  }
+
+                  return ValueOrErrors.Default.return([
+                    key,
                     {
-                      type: DispatchTypeName;
-                      methods: Array<TableMethod>;
-                      highlightedFilters?: List<ColumnName>;
-                      filtering?: TableApiFiltering<T>;
-                    }
-                  >(entries),
-                ),
-              )
-              .MapErrors((errors) =>
-                errors.map(
-                  (error) => `${error}\n...When deserializing table apis`,
-                ),
-              ),
+                      type: value.type,
+                      methods: finalMethods,
+                      highlightedFilters: value.highlightedFilters
+                        ? List(value.highlightedFilters)
+                        : undefined,
+                      filtering,
+                      sorting: finalSorting,
+                    },
+                  ]);
+                }),
+          ),
+        ),
+      )
+        .Then((entries) =>
+          ValueOrErrors.Default.return(
+            Map<
+              TableApiName,
+              {
+                type: DispatchTypeName;
+                methods: Array<TableMethod>;
+                highlightedFilters?: List<ColumnName>;
+                filtering?: TableApiFiltering<T>;
+              }
+            >(entries),
+          ),
+        )
+        .MapErrors((errors) =>
+          errors.map((error) => `${error}\n...When deserializing table apis`),
+        );
+    },
   },
 };
 
@@ -524,8 +529,8 @@ export const LookupApis = {
           ),
     Deserialize: (
       serializedApiLookups?: unknown,
-    ): ValueOrErrors<undefined | LookupApis, string> =>
-      serializedApiLookups === undefined
+    ): ValueOrErrors<undefined | LookupApis, string> => {
+      return serializedApiLookups === undefined
         ? ValueOrErrors.Default.return(undefined)
         : !isObject(serializedApiLookups)
           ? ValueOrErrors.Default.throwOne(
@@ -551,6 +556,7 @@ export const LookupApis = {
                 errors.map(
                   (error) => `${error}\n...When deserializing lookup apis`,
                 ),
-              ),
+              );
+    },
   },
 };