ballerina-core 1.0.186 → 1.0.187

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

@@ -1,105 +1,191 @@
 import { List, Map } from "immutable";
-import { isObject, isString, ValueOrErrors, } from "../../../../../../../../../main";
+import {
+  isObject,
+  isString,
+  ValueOrErrors,
+} from "../../../../../../../../../main";
 import { DispatchIsObject } from "../types/state";
 export const EnumApis = {
-    Operations: {
-        Deserialize: (serializedApiEnums) => serializedApiEnums === undefined
-            ? ValueOrErrors.Default.return(undefined)
-            : !isObject(serializedApiEnums)
-                ? ValueOrErrors.Default.throwOne(`serializedApiEnums is not an object`)
-                : ValueOrErrors.Operations.All(List(Object.entries(serializedApiEnums).map(([key, value]) => !isString(key)
+  Operations: {
+    Deserialize: (serializedApiEnums) =>
+      serializedApiEnums === undefined
+        ? ValueOrErrors.Default.return(undefined)
+        : !isObject(serializedApiEnums)
+          ? ValueOrErrors.Default.throwOne(
+              `serializedApiEnums is not an object`,
+            )
+          : ValueOrErrors.Operations.All(
+              List(
+                Object.entries(serializedApiEnums).map(([key, value]) =>
+                  !isString(key)
                     ? ValueOrErrors.Default.throwOne(`key is not a string`)
                     : !isString(value)
-                        ? ValueOrErrors.Default.throwOne(`value is not a string`)
-                        : ValueOrErrors.Default.return([key, value]))))
-                    .Then((entries) => ValueOrErrors.Default.return(Map(entries)))
-                    .MapErrors((errors) => errors.map((error) => `${error}\n...When deserializing enum apis`)),
-    },
+                      ? ValueOrErrors.Default.throwOne(`value is not a string`)
+                      : ValueOrErrors.Default.return([key, value]),
+                ),
+              ),
+            )
+              .Then((entries) => ValueOrErrors.Default.return(Map(entries)))
+              .MapErrors((errors) =>
+                errors.map(
+                  (error) => `${error}\n...When deserializing enum apis`,
+                ),
+              ),
+  },
 };
 export const StreamApis = {
-    Operations: {
-        Deserialize: (serializedApiStreams) => serializedApiStreams === undefined
-            ? ValueOrErrors.Default.return(undefined)
-            : !isObject(serializedApiStreams)
-                ? ValueOrErrors.Default.throwOne(`serializedApiStreams is not an object`)
-                : ValueOrErrors.Operations.All(List(Object.entries(serializedApiStreams).map(([key, value]) => !isString(key)
+  Operations: {
+    Deserialize: (serializedApiStreams) =>
+      serializedApiStreams === undefined
+        ? ValueOrErrors.Default.return(undefined)
+        : !isObject(serializedApiStreams)
+          ? ValueOrErrors.Default.throwOne(
+              `serializedApiStreams is not an object`,
+            )
+          : ValueOrErrors.Operations.All(
+              List(
+                Object.entries(serializedApiStreams).map(([key, value]) =>
+                  !isString(key)
                     ? ValueOrErrors.Default.throwOne(`key is not a string`)
                     : !isString(value)
-                        ? ValueOrErrors.Default.throwOne(`value is not a string`)
-                        : ValueOrErrors.Default.return([key, value]))))
-                    .Then((entries) => ValueOrErrors.Default.return(Map(entries)))
-                    .MapErrors((errors) => errors.map((error) => `${error}\n...When deserializing stream apis`)),
-    },
+                      ? ValueOrErrors.Default.throwOne(`value is not a string`)
+                      : ValueOrErrors.Default.return([key, value]),
+                ),
+              ),
+            )
+              .Then((entries) => ValueOrErrors.Default.return(Map(entries)))
+              .MapErrors((errors) =>
+                errors.map(
+                  (error) => `${error}\n...When deserializing stream apis`,
+                ),
+              ),
+  },
 };
 const TableMethods = {
-    add: "add",
-    duplicate: "duplicate",
-    remove: "remove",
-    move: "move",
+  add: "add",
+  duplicate: "duplicate",
+  remove: "remove",
+  move: "move",
 };
 export const TableApis = {
-    Operations: {
-        IsMethod: (value) => {
-            return (isString(value) &&
-                Object.values(TableMethods).includes(value));
-        },
-        IsMethodsArray: (values) => {
-            return values.every((value) => TableApis.Operations.IsMethod(value));
-        },
-        Deserialize: (serializedApiTables) => serializedApiTables === undefined
-            ? ValueOrErrors.Default.return(undefined)
-            : !isObject(serializedApiTables)
-                ? ValueOrErrors.Default.throwOne(`serializedApiTables is not an object`)
-                : ValueOrErrors.Operations.All(List(Object.entries(serializedApiTables).map(([key, value]) => !isString(key)
+  Operations: {
+    IsMethod: (value) => {
+      return isString(value) && Object.values(TableMethods).includes(value);
+    },
+    IsMethodsArray: (values) => {
+      return values.every((value) => TableApis.Operations.IsMethod(value));
+    },
+    Deserialize: (serializedApiTables) =>
+      serializedApiTables === undefined
+        ? ValueOrErrors.Default.return(undefined)
+        : !isObject(serializedApiTables)
+          ? ValueOrErrors.Default.throwOne(
+              `serializedApiTables is not an object`,
+            )
+          : ValueOrErrors.Operations.All(
+              List(
+                Object.entries(serializedApiTables).map(([key, value]) =>
+                  !isString(key)
                     ? ValueOrErrors.Default.throwOne(`key is not a string`)
                     : !isObject(value)
-                        ? ValueOrErrors.Default.throwOne(`value is not an object`)
-                        : !("type" in value)
-                            ? ValueOrErrors.Default.throwOne(`type is missing from value`)
-                            : !isString(value.type)
-                                ? ValueOrErrors.Default.throwOne(`type is not a string`)
-                                : !("methods" in value)
-                                    ? ValueOrErrors.Default.return([
-                                        key,
-                                        Object.assign(Object.assign({}, value), { methods: [] }),
-                                    ])
-                                    : !Array.isArray(value.methods)
-                                        ? ValueOrErrors.Default.throwOne(`methods is not an array`)
-                                        : !TableApis.Operations.IsMethodsArray(value.methods)
-                                            ? ValueOrErrors.Default.throwOne(`methods is not an array of valid table methods`)
-                                            : ValueOrErrors.Default.return([
-                                                key,
-                                                {
-                                                    // TODO: type assertion is safe but would like typescript to know that
-                                                    type: value.type,
-                                                    methods: value.methods,
-                                                },
-                                            ]))))
-                    .Then((entries) => ValueOrErrors.Default.return(Map(entries)))
-                    .MapErrors((errors) => errors.map((error) => `${error}\n...When deserializing table apis`)),
-    },
+                      ? ValueOrErrors.Default.throwOne(`value is not an object`)
+                      : !("type" in value)
+                        ? ValueOrErrors.Default.throwOne(
+                            `type is missing from value`,
+                          )
+                        : !isString(value.type)
+                          ? ValueOrErrors.Default.throwOne(
+                              `type is not a string`,
+                            )
+                          : !("methods" in value)
+                            ? ValueOrErrors.Default.return([
+                                key,
+                                Object.assign(Object.assign({}, value), {
+                                  methods: [],
+                                }),
+                              ])
+                            : !Array.isArray(value.methods)
+                              ? ValueOrErrors.Default.throwOne(
+                                  `methods is not an array`,
+                                )
+                              : !TableApis.Operations.IsMethodsArray(
+                                    value.methods,
+                                  )
+                                ? ValueOrErrors.Default.throwOne(
+                                    `methods is not an array of valid table methods`,
+                                  )
+                                : ValueOrErrors.Default.return([
+                                    key,
+                                    {
+                                      // TODO: type assertion is safe but would like typescript to know that
+                                      type: value.type,
+                                      methods: value.methods,
+                                    },
+                                  ]),
+                ),
+              ),
+            )
+              .Then((entries) => ValueOrErrors.Default.return(Map(entries)))
+              .MapErrors((errors) =>
+                errors.map(
+                  (error) => `${error}\n...When deserializing table apis`,
+                ),
+              ),
+  },
 };
 // TODO add many deserialization
 export const LookupApis = {
-    Operations: {
-        isLookupApi: (_) => DispatchIsObject(_),
-        DeserializeOne: (serializedLookupApi) => !LookupApis.Operations.isLookupApi(serializedLookupApi)
-            ? ValueOrErrors.Default.throwOne(`serializedLookupApi is not an object`)
-            : EnumApis.Operations.Deserialize(serializedLookupApi.enums)
-                .Then((enums) => StreamApis.Operations.Deserialize(serializedLookupApi.streams).Then((streams) => TableApis.Operations.Deserialize(serializedLookupApi.tables).Then((tables) => LookupApis.Operations.Deserialize(serializedLookupApi.lookups).Then((lookups) => ValueOrErrors.Default.return({
-                enums,
-                streams,
-                tables,
-                lookups,
-            })))))
-                .MapErrors((errors) => errors.map((error) => `${error}\n...When deserializing lookup api`)),
-        Deserialize: (serializedApiLookups) => serializedApiLookups === undefined
-            ? ValueOrErrors.Default.return(undefined)
-            : !isObject(serializedApiLookups)
-                ? ValueOrErrors.Default.throwOne(`serializedApiLookups is not an object`)
-                : ValueOrErrors.Operations.All(List(Object.entries(serializedApiLookups).map(([key, value]) => ValueOrErrors.Default.return([key, value]))))
-                    .Then((entries) => ValueOrErrors.Default.return(Map(entries)))
-                    .MapErrors((errors) => errors.map((error) => `${error}\n...When deserializing lookup apis`)),
-    },
+  Operations: {
+    isLookupApi: (_) => DispatchIsObject(_),
+    DeserializeOne: (serializedLookupApi) =>
+      !LookupApis.Operations.isLookupApi(serializedLookupApi)
+        ? ValueOrErrors.Default.throwOne(`serializedLookupApi is not an object`)
+        : EnumApis.Operations.Deserialize(serializedLookupApi.enums)
+            .Then((enums) =>
+              StreamApis.Operations.Deserialize(
+                serializedLookupApi.streams,
+              ).Then((streams) =>
+                TableApis.Operations.Deserialize(
+                  serializedLookupApi.tables,
+                ).Then((tables) =>
+                  LookupApis.Operations.Deserialize(
+                    serializedLookupApi.lookups,
+                  ).Then((lookups) =>
+                    ValueOrErrors.Default.return({
+                      enums,
+                      streams,
+                      tables,
+                      lookups,
+                    }),
+                  ),
+                ),
+              ),
+            )
+            .MapErrors((errors) =>
+              errors.map(
+                (error) => `${error}\n...When deserializing lookup api`,
+              ),
+            ),
+    Deserialize: (serializedApiLookups) =>
+      serializedApiLookups === undefined
+        ? ValueOrErrors.Default.return(undefined)
+        : !isObject(serializedApiLookups)
+          ? ValueOrErrors.Default.throwOne(
+              `serializedApiLookups is not an object`,
+            )
+          : ValueOrErrors.Operations.All(
+              List(
+                Object.entries(serializedApiLookups).map(([key, value]) =>
+                  ValueOrErrors.Default.return([key, value]),
+                ),
+              ),
+            )
+              .Then((entries) => ValueOrErrors.Default.return(Map(entries)))
+              .MapErrors((errors) =>
+                errors.map(
+                  (error) => `${error}\n...When deserializing lookup apis`,
+                ),
+              ),
+  },
 };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/bin/src/forms/domains/dispatched-forms/deserializer/domains/specification/domains/forms/domains/renderer/domains/enum/state.d.ts

@@ -1,27 +1,43 @@
-import { DispatchInjectablesTypes, Guid, ValueOrErrors } from "../../../../../../../../../../../../../main";
-import { MultiSelectionType, SingleSelectionType } from "../../../../../types/state";
+import {
+  DispatchInjectablesTypes,
+  Guid,
+  ValueOrErrors,
+} from "../../../../../../../../../../../../../main";
+import {
+  MultiSelectionType,
+  SingleSelectionType,
+} from "../../../../../types/state";
 import { SerializedRenderer } from "../../state";
 export type SerializedEnumRenderer = {
-    renderer: string;
-    options: string;
+  renderer: string;
+  options: string;
 };
 export type EnumRenderer<T> = {
-    kind: "enumRenderer";
-    concreteRenderer: string;
-    options: Guid;
-    type: SingleSelectionType<T> | MultiSelectionType<T>;
+  kind: "enumRenderer";
+  concreteRenderer: string;
+  options: Guid;
+  type: SingleSelectionType<T> | MultiSelectionType<T>;
 };
 export declare const EnumRenderer: {
-    Default: <T extends DispatchInjectablesTypes<T>>(type: SingleSelectionType<T> | MultiSelectionType<T>, options: string, concreteRenderer: string) => EnumRenderer<T>;
-    Operations: {
-        hasRenderer: (serialized: unknown) => serialized is object & {
-            renderer: SerializedRenderer;
-        };
-        hasOptions: (serialized: unknown) => serialized is object & {
-            options: string;
-        };
-        tryAsValidEnumRenderer: <T extends DispatchInjectablesTypes<T>>(serialized: unknown) => ValueOrErrors<SerializedEnumRenderer, string>;
-        Deserialize: <T extends DispatchInjectablesTypes<T>>(type: SingleSelectionType<T> | MultiSelectionType<T>, serialized: unknown) => ValueOrErrors<EnumRenderer<T>, string>;
+  Default: <T extends DispatchInjectablesTypes<T>>(
+    type: SingleSelectionType<T> | MultiSelectionType<T>,
+    options: string,
+    concreteRenderer: string,
+  ) => EnumRenderer<T>;
+  Operations: {
+    hasRenderer: (serialized: unknown) => serialized is object & {
+      renderer: SerializedRenderer;
     };
+    hasOptions: (serialized: unknown) => serialized is object & {
+      options: string;
+    };
+    tryAsValidEnumRenderer: <T extends DispatchInjectablesTypes<T>>(
+      serialized: unknown,
+    ) => ValueOrErrors<SerializedEnumRenderer, string>;
+    Deserialize: <T extends DispatchInjectablesTypes<T>>(
+      type: SingleSelectionType<T> | MultiSelectionType<T>,
+      serialized: unknown,
+    ) => ValueOrErrors<EnumRenderer<T>, string>;
+  };
 };
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

package/bin/src/forms/domains/dispatched-forms/deserializer/domains/specification/domains/forms/domains/renderer/domains/enum/state.js

@@ -1,29 +1,42 @@
-import { isObject, isString, ValueOrErrors, } from "../../../../../../../../../../../../../main";
+import {
+  isObject,
+  isString,
+  ValueOrErrors,
+} from "../../../../../../../../../../../../../main";
 export const EnumRenderer = {
-    Default: (type, options, concreteRenderer) => ({
-        kind: "enumRenderer",
-        type,
-        options,
-        concreteRenderer,
-    }),
-    Operations: {
-        hasRenderer: (serialized) => isObject(serialized) && "renderer" in serialized,
-        hasOptions: (serialized) => isObject(serialized) && "options" in serialized,
-        tryAsValidEnumRenderer: (serialized) => !EnumRenderer.Operations.hasRenderer(serialized)
-            ? ValueOrErrors.Default.throwOne(`renderer is required`)
-            : !isString(serialized.renderer)
-                ? ValueOrErrors.Default.throwOne(`renderer must be a string`)
-                : !EnumRenderer.Operations.hasOptions(serialized)
-                    ? ValueOrErrors.Default.throwOne(`options are required`)
-                    : !isString(serialized.options)
-                        ? ValueOrErrors.Default.throwOne(`options must be a string`)
-                        : ValueOrErrors.Default.return({
-                            renderer: serialized.renderer,
-                            options: serialized.options,
-                        }),
-        Deserialize: (type, serialized) => EnumRenderer.Operations.tryAsValidEnumRenderer(serialized)
-            .Then((serialized) => ValueOrErrors.Default.return(EnumRenderer.Default(type, serialized.options, serialized.renderer)))
-            .MapErrors((errors) => errors.map((error) => `${error}\n...When parsing as EnumRenderer`)),
-    },
+  Default: (type, options, concreteRenderer) => ({
+    kind: "enumRenderer",
+    type,
+    options,
+    concreteRenderer,
+  }),
+  Operations: {
+    hasRenderer: (serialized) =>
+      isObject(serialized) && "renderer" in serialized,
+    hasOptions: (serialized) => isObject(serialized) && "options" in serialized,
+    tryAsValidEnumRenderer: (serialized) =>
+      !EnumRenderer.Operations.hasRenderer(serialized)
+        ? ValueOrErrors.Default.throwOne(`renderer is required`)
+        : !isString(serialized.renderer)
+          ? ValueOrErrors.Default.throwOne(`renderer must be a string`)
+          : !EnumRenderer.Operations.hasOptions(serialized)
+            ? ValueOrErrors.Default.throwOne(`options are required`)
+            : !isString(serialized.options)
+              ? ValueOrErrors.Default.throwOne(`options must be a string`)
+              : ValueOrErrors.Default.return({
+                  renderer: serialized.renderer,
+                  options: serialized.options,
+                }),
+    Deserialize: (type, serialized) =>
+      EnumRenderer.Operations.tryAsValidEnumRenderer(serialized)
+        .Then((serialized) =>
+          ValueOrErrors.Default.return(
+            EnumRenderer.Default(type, serialized.options, serialized.renderer),
+          ),
+        )
+        .MapErrors((errors) =>
+          errors.map((error) => `${error}\n...When parsing as EnumRenderer`),
+        ),
+  },
 };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/bin/src/forms/domains/dispatched-forms/deserializer/domains/specification/domains/forms/domains/renderer/domains/list/state.d.ts

@@ -1,43 +1,75 @@
 import { Map } from "immutable";
-import { ConcreteRenderers, DispatchInjectablesTypes, DispatchParsedType, ListType, ValueOrErrors } from "../../../../../../../../../../../../../main";
+import {
+  ConcreteRenderers,
+  DispatchInjectablesTypes,
+  DispatchParsedType,
+  ListType,
+  ValueOrErrors,
+} from "../../../../../../../../../../../../../main";
 import { NestedRenderer } from "../nestedRenderer/state";
 export type SerializedListRenderer = {
-    renderer: string;
-    elementRenderer: unknown;
-    actions: unknown;
+  renderer: string;
+  elementRenderer: unknown;
+  actions: unknown;
 };
 export declare const ListMethod: {
-    readonly add: "add";
-    readonly remove: "remove";
-    readonly move: "move";
-    readonly duplicate: "duplicate";
+  readonly add: "add";
+  readonly remove: "remove";
+  readonly move: "move";
+  readonly duplicate: "duplicate";
 };
 export type ListMethod = (typeof ListMethod)[keyof typeof ListMethod];
 export type ListMethods = Array<ListMethod>;
 export declare const ListMethods: {
-    Operations: {
-        fromRawValue: (value: unknown) => ValueOrErrors<ListMethods, string>;
-    };
+  Operations: {
+    fromRawValue: (value: unknown) => ValueOrErrors<ListMethods, string>;
+  };
 };
 export type ListRenderer<T> = {
-    kind: "listRenderer";
-    concreteRenderer: string;
-    elementRenderer: NestedRenderer<T>;
-    type: ListType<T>;
-    methods: Array<ListMethod>;
+  kind: "listRenderer";
+  concreteRenderer: string;
+  elementRenderer: NestedRenderer<T>;
+  type: ListType<T>;
+  methods: Array<ListMethod>;
 };
 export declare const ListRenderer: {
-    Default: <T>(type: ListType<T>, concreteRenderer: string, elementRenderer: NestedRenderer<T>, methods?: ListRenderer<T>["methods"]) => ListRenderer<T>;
-    Operations: {
-        hasRenderers: (serialized: unknown) => serialized is object & {
-            renderer: string;
-            elementRenderer: unknown;
-        };
-        tryAsValidBaseListRenderer: <T>(serialized: unknown, type: DispatchParsedType<T>) => ValueOrErrors<Omit<SerializedListRenderer, "renderer" | "elementRenderer"> & {
-            renderer: string;
-            elementRenderer: unknown;
-        }, string>;
-        Deserialize: <T extends DispatchInjectablesTypes<T>, Flags, CustomPresentationContexts, ExtraContext>(type: ListType<T>, serialized: unknown, concreteRenderers: ConcreteRenderers<T, Flags, CustomPresentationContexts, ExtraContext>, types: Map<string, DispatchParsedType<T>>) => ValueOrErrors<ListRenderer<T>, string>;
+  Default: <T>(
+    type: ListType<T>,
+    concreteRenderer: string,
+    elementRenderer: NestedRenderer<T>,
+    methods?: ListRenderer<T>["methods"],
+  ) => ListRenderer<T>;
+  Operations: {
+    hasRenderers: (serialized: unknown) => serialized is object & {
+      renderer: string;
+      elementRenderer: unknown;
     };
+    tryAsValidBaseListRenderer: <T>(
+      serialized: unknown,
+      type: DispatchParsedType<T>,
+    ) => ValueOrErrors<
+      Omit<SerializedListRenderer, "renderer" | "elementRenderer"> & {
+        renderer: string;
+        elementRenderer: unknown;
+      },
+      string
+    >;
+    Deserialize: <
+      T extends DispatchInjectablesTypes<T>,
+      Flags,
+      CustomPresentationContexts,
+      ExtraContext,
+    >(
+      type: ListType<T>,
+      serialized: unknown,
+      concreteRenderers: ConcreteRenderers<
+        T,
+        Flags,
+        CustomPresentationContexts,
+        ExtraContext
+      >,
+      types: Map<string, DispatchParsedType<T>>,
+    ) => ValueOrErrors<ListRenderer<T>, string>;
+  };
 };
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

package/bin/src/forms/domains/dispatched-forms/deserializer/domains/specification/domains/forms/domains/renderer/domains/list/state.js

@@ -1,48 +1,84 @@
-import { isObject, ValueOrErrors, } from "../../../../../../../../../../../../../main";
+import {
+  isObject,
+  ValueOrErrors,
+} from "../../../../../../../../../../../../../main";
 import { NestedRenderer } from "../nestedRenderer/state";
 export const ListMethod = {
-    add: "add",
-    remove: "remove",
-    move: "move",
-    duplicate: "duplicate",
+  add: "add",
+  remove: "remove",
+  move: "move",
+  duplicate: "duplicate",
 };
 export const ListMethods = {
-    Operations: {
-        fromRawValue: (value) => typeof value === "undefined"
+  Operations: {
+    fromRawValue: (value) =>
+      typeof value === "undefined"
+        ? ValueOrErrors.Default.return([])
+        : typeof value !== "object" || value == null
+          ? ValueOrErrors.Default.throwOne(
+              `expected an object for list methods, got ${typeof value}`,
+            )
+          : Object.keys(value).length == 0
             ? ValueOrErrors.Default.return([])
-            : typeof value !== "object" || value == null
-                ? ValueOrErrors.Default.throwOne(`expected an object for list methods, got ${typeof value}`)
-                : Object.keys(value).length == 0
-                    ? ValueOrErrors.Default.return([])
-                    : Object.keys(value).find((_) => !ListMethod[_])
-                        ? ValueOrErrors.Default.throwOne(`expected an object with keys ${Object.keys(ListMethod).join(", ")}, got ${Object.keys(value).join(", ")}`)
-                        : ValueOrErrors.Default.return(Object.keys(value)),
-    },
+            : Object.keys(value).find((_) => !ListMethod[_])
+              ? ValueOrErrors.Default.throwOne(
+                  `expected an object with keys ${Object.keys(ListMethod).join(", ")}, got ${Object.keys(value).join(", ")}`,
+                )
+              : ValueOrErrors.Default.return(Object.keys(value)),
+  },
 };
 export const ListRenderer = {
-    Default: (type, concreteRenderer, elementRenderer, methods) => ({
-        kind: "listRenderer",
-        type,
-        concreteRenderer,
-        elementRenderer,
-        methods: methods !== null && methods !== void 0 ? methods : [],
-    }),
-    Operations: {
-        hasRenderers: (serialized) => isObject(serialized) &&
-            "renderer" in serialized &&
-            "elementRenderer" in serialized,
-        tryAsValidBaseListRenderer: (serialized, type) => type.kind != "list"
-            ? ValueOrErrors.Default.throwOne(`type ${type.kind} is not a list`)
-            : !ListRenderer.Operations.hasRenderers(serialized)
-                ? ValueOrErrors.Default.throwOne(`renderer and elementRenderer are required`)
-                : ValueOrErrors.Default.return({
-                    actions: "actions" in serialized ? serialized.actions : [],
-                    renderer: serialized.renderer,
-                    elementRenderer: serialized.elementRenderer,
-                }),
-        Deserialize: (type, serialized, concreteRenderers, types) => ListRenderer.Operations.tryAsValidBaseListRenderer(serialized, type)
-            .Then((serializedRenderer) => NestedRenderer.Operations.DeserializeAs(type.args[0], serializedRenderer.elementRenderer, concreteRenderers, "list element", types).Then((elementRenderer) => ListMethods.Operations.fromRawValue(serializedRenderer.actions).Then((methods) => ValueOrErrors.Default.return(ListRenderer.Default(type, serializedRenderer.renderer, elementRenderer, methods)))))
-            .MapErrors((errors) => errors.map((error) => `${error}\n...When parsing as List`)),
-    },
+  Default: (type, concreteRenderer, elementRenderer, methods) => ({
+    kind: "listRenderer",
+    type,
+    concreteRenderer,
+    elementRenderer,
+    methods: methods !== null && methods !== void 0 ? methods : [],
+  }),
+  Operations: {
+    hasRenderers: (serialized) =>
+      isObject(serialized) &&
+      "renderer" in serialized &&
+      "elementRenderer" in serialized,
+    tryAsValidBaseListRenderer: (serialized, type) =>
+      type.kind != "list"
+        ? ValueOrErrors.Default.throwOne(`type ${type.kind} is not a list`)
+        : !ListRenderer.Operations.hasRenderers(serialized)
+          ? ValueOrErrors.Default.throwOne(
+              `renderer and elementRenderer are required`,
+            )
+          : ValueOrErrors.Default.return({
+              actions: "actions" in serialized ? serialized.actions : [],
+              renderer: serialized.renderer,
+              elementRenderer: serialized.elementRenderer,
+            }),
+    Deserialize: (type, serialized, concreteRenderers, types) =>
+      ListRenderer.Operations.tryAsValidBaseListRenderer(serialized, type)
+        .Then((serializedRenderer) =>
+          NestedRenderer.Operations.DeserializeAs(
+            type.args[0],
+            serializedRenderer.elementRenderer,
+            concreteRenderers,
+            "list element",
+            types,
+          ).Then((elementRenderer) =>
+            ListMethods.Operations.fromRawValue(
+              serializedRenderer.actions,
+            ).Then((methods) =>
+              ValueOrErrors.Default.return(
+                ListRenderer.Default(
+                  type,
+                  serializedRenderer.renderer,
+                  elementRenderer,
+                  methods,
+                ),
+              ),
+            ),
+          ),
+        )
+        .MapErrors((errors) =>
+          errors.map((error) => `${error}\n...When parsing as List`),
+        ),
+  },
 };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map