ballerina-core 1.0.50 → 1.0.51

package/package.json

@@ -2,7 +2,7 @@
   "name": "ballerina-core",
   "author": "Dr. Giuseppe Maggiore",
   "private": false,
-  "version": "1.0.50",
+  "version": "1.0.51",
   "main": "main.ts",
   "dependencies": {
     "immutable": "^5.0.0-beta.5",

package/src/collections/domains/valueOrErrors/state.ts

@@ -7,25 +7,25 @@ export type ValueOrErrors<v, e> = (
   | (Value<v> & { kind: "value" })
   | { errors: List<e>; kind: "errors" }
 ) & {
-  map: <a, b, e>(
+  Map: <a, b, e>(
     this: ValueOrErrors<a, e>,
     f: BasicFun<a, b>
   ) => ValueOrErrors<b, e>;
-  mapErrors: <a, e, e2>(
+  MapErrors: <a, e, e2>(
     this: ValueOrErrors<a, e>,
     f: BasicFun<List<e>, List<e2>>
   ) => ValueOrErrors<a, e2>;
-  flatten: <a, e>(
+  Flatten: <a, e>(
     this: ValueOrErrors<ValueOrErrors<a, e>, e>
   ) => ValueOrErrors<a, e>;
-  bind: <a, b, e>(
+  Then: <a, b, e>(
     this: ValueOrErrors<a, e>,
     k: BasicFun<a, ValueOrErrors<b, e>>
   ) => ValueOrErrors<b, e>;
 };
 
 const operations = {
-  map: function <a, b, e>(
+  Map: function <a, b, e>(
     this: ValueOrErrors<a, e>,
     f: BasicFun<a, b>
   ): ValueOrErrors<b, e> {
@@ -34,7 +34,7 @@ const operations = {
     }
     return ValueOrErrors.Default.return(f(this.value));
   },
-  mapErrors: function <a, e, e2>(
+  MapErrors: function <a, e, e2>(
     this: ValueOrErrors<a, e>,
     f: BasicFun<List<e>, List<e2>>
   ): ValueOrErrors<a, e2> {
@@ -43,7 +43,7 @@ const operations = {
     }
     return this;
   },
-  flatten: function <a, e>(
+  Flatten: function <a, e>(
     this: ValueOrErrors<ValueOrErrors<a, e>, e>
   ): ValueOrErrors<a, e> {
     if (this.kind == "errors") {
@@ -54,11 +54,11 @@ const operations = {
       return this.value;
     }
   },
-  bind: function <a, b, e>(
+  Then: function <a, b, e>(
     this: ValueOrErrors<a, e>,
     k: BasicFun<a, ValueOrErrors<b, e>>
   ): ValueOrErrors<b, e> {
-    return this.map(k).flatten();
+    return this.Map(k).Flatten();
   },
 };
 
@@ -76,23 +76,23 @@ export const ValueOrErrors = {
     }),
   },
   Operations: {
-    return: <v, e>(_: v): ValueOrErrors<v, e> =>
+    Return: <v, e>(_: v): ValueOrErrors<v, e> =>
       ValueOrErrors.Default.return(_),
-    throw: <v, e>(_: e): ValueOrErrors<v, e> =>
-      ValueOrErrors.Default.throw(List([_])),
-    map: <a, b, e>(
+    Throw: <v, e>(_: List<e>): ValueOrErrors<v, e> =>
+      ValueOrErrors.Default.throw(_),
+    Map: <a, b, e>(
       f: BasicFun<a, b>
     ): Fun<ValueOrErrors<a, e>, ValueOrErrors<b, e>> =>
       Fun((_) =>
         _.kind == "errors" ? _ : ValueOrErrors.Default.return(f(_.value))
       ),
-    mapErrors: <a, e, e2>(
+    MapErrors: <a, e, e2>(
       f: BasicFun<List<e>, List<e2>>
     ): BasicFun<ValueOrErrors<a, e>, ValueOrErrors<a, e2>> =>
       Fun((_) =>
         _.kind == "errors" ? ValueOrErrors.Default.throw(f(_.errors)) : _
       ),
-    flatten: <a, e>(): Fun<
+    Flatten: <a, e>(): Fun<
       ValueOrErrors<ValueOrErrors<a, e>, e>,
       ValueOrErrors<a, e>
     > =>
@@ -105,30 +105,30 @@ export const ValueOrErrors = {
           return _.value;
         }
       }),
-    then: <a, b, e>(
+    Then: <a, b, e>(
       k: BasicFun<a, ValueOrErrors<b, e>>
     ): Fun<ValueOrErrors<a, e>, ValueOrErrors<b, e>> =>
       Fun((_: ValueOrErrors<a, e>) =>
-        ValueOrErrors.Operations.flatten<b, e>()(
-          ValueOrErrors.Operations.map<a, ValueOrErrors<b, e>, e>(k)(_)
+        ValueOrErrors.Operations.Flatten<b, e>()(
+          ValueOrErrors.Operations.Map<a, ValueOrErrors<b, e>, e>(k)(_)
         )
       ),
-    fold: <v, e, c>(
+    Fold: <v, e, c>(
       l: BasicFun<v, c>,
       r: BasicFun<List<e>, c>
     ): Fun<ValueOrErrors<v, e>, c> =>
       Fun((_) => (_.kind == "value" ? l(_.value) : r(_.errors))),
-    all: <v, e>(_: List<ValueOrErrors<v, e>>): ValueOrErrors<List<v>, e> =>
+    All: <v, e>(_: List<ValueOrErrors<v, e>>): ValueOrErrors<List<v>, e> =>
       _.reduce(
         (reduction, value) =>
-          ValueOrErrors.Operations.fold<v, e, ValueOrErrors<List<v>, e>>(
+          ValueOrErrors.Operations.Fold<v, e, ValueOrErrors<List<v>, e>>(
             (v: v) =>
               reduction.kind == "errors"
                 ? reduction
-                : reduction.map((_) => _.concat(v)),
+                : reduction.Map((_) => _.concat(v)),
             (es: List<e>) =>
               reduction.kind == "errors"
-                ? reduction.mapErrors((_) => _.concat(es))
+                ? reduction.MapErrors((_) => _.concat(es))
                 : ValueOrErrors.Default.throw(es)
           )(value),
         ValueOrErrors.Default.return(List<v>())

package/src/forms/domains/launcher/domains/edit/coroutines/runner.ts

@@ -37,15 +37,27 @@ export const editFormRunner = <E, FS>() => {
           EditFormState<E, FS>().Updaters.Template.toUnchecked()
         ),
         Debounce<Synchronized<Unit, ApiErrors>, EditFormWritableState<E, FS>>(
-          Synchronize<Unit, ApiErrors, EditFormWritableState<E, FS>>(
-            (_) =>
-              current.entity.sync.kind == "loaded"
-                ? current.api.update(current.entityId, current.entity.sync.value,  current.formState)
-                : Promise.resolve([]),
-            (_) => "transient failure",
-            5,
-            50
-          ),
+          (() => {
+            if(current.entity.sync.kind != "loaded") return Synchronize<Unit, ApiErrors, EditFormWritableState<E, FS>>(
+              (_) => Promise.resolve([]),
+              (_) => "transient failure",
+              5,
+              50
+            )
+            const parsed = current.parser(current.entity.sync.value,  current.formState)
+
+            return Synchronize<Unit, ApiErrors, EditFormWritableState<E, FS>>(
+              (_) =>
+                { 
+                  if(parsed.kind == "errors") return Promise.reject(parsed.errors)
+                  return current.api.update(current.entityId, parsed)
+                },
+              (_) => "transient failure",
+              parsed.kind == "errors" ? 1 : 5,
+              50
+            )
+          })(),
+
           15
         ).embed(
           (_) => ({ ..._, ..._.apiRunner }),

package/src/forms/domains/launcher/domains/edit/state.ts

@@ -1,4 +1,5 @@
 import { ApiResponseChecker, AsyncState, BasicUpdater, Debounced, ForeignMutationsInput, Guid, id, SimpleCallback, simpleUpdater, Synchronized, Template, unit, Unit, Updater, Value } from "../../../../../../main"
+import { ValueOrErrors } from "../../../../../collections/domains/valueOrErrors/state"
 import { BasicFun } from "../../../../../fun/state"
 
 export type ApiErrors = Array<string>
@@ -7,8 +8,9 @@ export type EditFormContext<E,FS> = {
   entityId:string,
   api:{
     get:(id: Guid) => Promise<E>,
-    update:(id: Guid, entity:E, formstate: FS) => Promise<ApiErrors>
+    update:(id: Guid, raw: any) => Promise<ApiErrors>
   },
+  parser: (entity:E, formstate: FS) => ValueOrErrors<E, ApiErrors>
   actualForm:Template<Value<E> & FS, FS, { onChange:SimpleCallback<BasicUpdater<E>>}>
 }
 

package/src/forms/domains/parser/domains/built-ins/state.ts

@@ -2,7 +2,7 @@ import { Map, List, Set, OrderedMap } from "immutable"
 import { CollectionReference } from "../../../collection/domains/reference/state";
 import { CollectionSelection } from "../../../collection/domains/selection/state";
 import { BasicFun } from "../../../../../fun/state";
-import { InjectedPrimitives, Maybe, replaceKeyword, replaceKeywords, revertKeyword, Type, TypeDefinition, TypeName, Unit, Value } from "../../../../../../main";
+import { InjectedPrimitives, Maybe, replaceKeyword, replaceKeywords, revertKeyword, Sum, Type, TypeDefinition, TypeName, Unit, Value } from "../../../../../../main";
 import { ValueOrErrors } from "../../../../../collections/domains/valueOrErrors/state";
 
 export const PrimitiveTypes =
@@ -186,7 +186,6 @@ export const fromAPIRawValue = <T>(t: Type, types: Map<TypeName, TypeDefinition>
       return result
     }
     if (t.value == "Map" && t.args.length == 2) {
-      console.log("t", t)
       let result = converters[t.value].fromAPIRawValue(obj)
 
       const isKeyPrimitive = typeof t.args[0] == "string" && PrimitiveTypes.some(_ => _ == t.args[0]) || injectedPrimitives?.injectedPrimitives.has(t.args[0] as keyof T) 
@@ -229,24 +228,24 @@ export const fromAPIRawValue = <T>(t: Type, types: Map<TypeName, TypeDefinition>
 export const toAPIRawValue = <T>(t: Type, types: Map<TypeName, TypeDefinition>, builtIns: BuiltIns, converters: BuiltInApiConverters, isKeywordsReverted: boolean = false, injectedPrimitives?: InjectedPrimitives<T>) => (raw: any, formState: any) : ValueOrErrors<any, string> => {
   const obj = !isKeywordsReverted ? replaceKeywords(raw, "to api") : raw
   if (t.kind == "primitive") {
-    return ValueOrErrors.Operations.return(converters[t.value].toAPIRawValue([obj, formState.modifiedByUser] as never))
+    return ValueOrErrors.Operations.Return(converters[t.value].toAPIRawValue([obj, formState.modifiedByUser] as never))
   } else if (t.kind == "application") { // application here means "generic type application"
     if (t.value == "SingleSelection" && t.args.length == 1) {
       const result = converters[t.value].toAPIRawValue([obj, formState.modifiedByUser])
-      if(typeof result != "object") return ValueOrErrors.Operations.return(result)
+      if(typeof result != "object") return ValueOrErrors.Operations.Return(result)
       
       return toAPIRawValue({ kind:"lookup", name:t.args[0] }, types, builtIns, converters, true, injectedPrimitives)(result, formState)
     }
     if ((t.value == "Multiselection" || t.value == "MultiSelection") && t.args.length == 1) {
       const result = converters["MultiSelection"].toAPIRawValue([obj, formState.modifiedByUser])
 
-      return ValueOrErrors.Operations.all(List<ValueOrErrors<any, string>>(result.map((_:any) =>
-        typeof _ == "object" ? toAPIRawValue({ kind:"lookup", name: t.args[0] }, types, builtIns, converters, true, injectedPrimitives)(_, formState) : ValueOrErrors.Operations.return(_))))
+      return ValueOrErrors.Operations.All(List<ValueOrErrors<any, string>>(result.map((_:any) =>
+        typeof _ == "object" ? toAPIRawValue({ kind:"lookup", name: t.args[0] }, types, builtIns, converters, true, injectedPrimitives)(_, formState) : ValueOrErrors.Operations.Return(_))))
     }
     if (t.value == "List" && t.args.length == 1) {
       const converterResult = converters[t.value].toAPIRawValue([obj, formState.modifiedByUser])
       const isPrimitive = PrimitiveTypes.some(_ => _ == t.args[0]) || injectedPrimitives?.injectedPrimitives.has(t.args[0] as keyof T) 
-      return ValueOrErrors.Operations.all(List<ValueOrErrors<any, string>>(converterResult.map((item: any, index: number) =>
+      return ValueOrErrors.Operations.All(List<ValueOrErrors<any, string>>(converterResult.map((item: any, index: number) =>
         toAPIRawValue(
           isPrimitive ?
             { kind:"primitive", value:t.args[0] as PrimitiveType }
@@ -256,12 +255,12 @@ export const toAPIRawValue = <T>(t: Type, types: Map<TypeName, TypeDefinition>,
       ))))
     }
     if (t.value == "Map" && t.args.length == 2) {
-      const converterResult = converters[t.value].toAPIRawValue([obj, formState.modifiedByUser])
+      const [converterResult, toIdentiferAndDisplayName] = converters[t.value].toAPIRawValue([obj, formState.modifiedByUser])
       const isKeyPrimitive = PrimitiveTypes.some(_ => _ == t.args[0]) || injectedPrimitives?.injectedPrimitives.has(t.args[0] as keyof T)
       const isValuePrimitive = PrimitiveTypes.some(_ => _ == t.args[1]) || injectedPrimitives?.injectedPrimitives.has(t.args[1] as keyof T)
 
-      const parsedMap: ValueOrErrors<{key: ValueOrErrors<any, any>, value: ValueOrErrors<any, any>}, any>[] = converterResult.map((keyValue: any, index: number) => {
-        const key = toAPIRawValue(
+      const parsedMap: List<ValueOrErrors<{key: ValueOrErrors<any, any>, value: ValueOrErrors<any, any>}, any>> = converterResult.map((keyValue: any, index: number) => {
+        const possiblyUndefinedKey = toAPIRawValue(
           typeof t.args[0] == "string" ? 
             isKeyPrimitive ?
               { kind: "primitive", value: t.args[0] as PrimitiveType }
@@ -271,11 +270,12 @@ export const toAPIRawValue = <T>(t: Type, types: Map<TypeName, TypeDefinition>,
             types, builtIns, converters, true, injectedPrimitives)(keyValue[0], formState.elementFormStates.get(index).KeyFormState
           )
 
-          if(key.kind == "value" && (key.value == undefined || key.value == null)) {
-            return ValueOrErrors.Operations.throw([`A mapped key is undefined for type ${JSON.stringify(t.args[0])}`])
-          } else if ( key.kind == "errors"){
-            return key
-          }
+          const key: ValueOrErrors<any, string> = (() => {
+            if(possiblyUndefinedKey.kind == "value" && (possiblyUndefinedKey.value == undefined || possiblyUndefinedKey.value == null || possiblyUndefinedKey.value == "" || (typeof possiblyUndefinedKey.value == "object" && Object.keys(possiblyUndefinedKey.value).length == 0))) {
+              return ValueOrErrors.Operations.Throw(List([`A mapped key is undefined for type ${JSON.stringify(t.args[0])}`]))
+            }
+            return possiblyUndefinedKey
+          })()
 
           const value = toAPIRawValue(
             typeof t.args[1] == "string" ? 
@@ -286,31 +286,22 @@ export const toAPIRawValue = <T>(t: Type, types: Map<TypeName, TypeDefinition>,
               t.args[1], 
             types, builtIns, converters, true, injectedPrimitives)(keyValue[1], formState.elementFormStates.get(index).ValueFormState)
 
-          if(value.kind == "errors") return value
-
-          return ValueOrErrors.Operations.return({key, value})
+          return key.kind == "errors" || value.kind == "errors" ? ValueOrErrors.Operations.All(List([key, value]))  : ValueOrErrors.Default.return({key: key.value, value: value.value})
         }
       )
-
-      if(parsedMap.length > 0 && parsedMap.some((_: ValueOrErrors<any, any>) => _.kind == "errors")) {
-        return ValueOrErrors.Operations.all(List(parsedMap))
-      }
-      // TODO this needs improvement
-      const allKeysStringified = parsedMap.map((_) => _.kind == "value" ? JSON.stringify((_.value.key as any).value) : "")
-      const allKeysUnique = Set(allKeysStringified).size == allKeysStringified.length
-
-      if(allKeysStringified.length > 0 && !allKeysUnique) {
-        return ValueOrErrors.Operations.throw(`Keys in the map are not unique: ${JSON.stringify(allKeysStringified)}`)
-      }
       
-      // return ValueOrErrors.Operations.return(parsedMap.map(_ => _.flatten()))
-      return ValueOrErrors.Operations.return(parsedMap.map(_ => (_ as any).map(({key, value}: {key: any, value: any}) => ({key: key.value, value: value.value}))).map((_: any) => _.value))
+      const nonUniqueKeyErrors = parsedMap.filter(_ => _.kind == "value").reduce((acc, _) => { 
+        const [id, displayName] = toIdentiferAndDisplayName(_.value.key)
+        acc.ids.contains(id) ? acc.errors = acc.errors.push(ValueOrErrors.Default.throw(List([`Keys in the map are not unique: ${displayName}`]))) : acc.ids = acc.ids.push(id)
+        return acc
+      }, {ids: List<string>(), errors: List<ValueOrErrors<any, string>>()}).errors
 
+      return ValueOrErrors.Operations.All(parsedMap.concat(nonUniqueKeyErrors))
     }
   } else { // t.kind == lookup: we are dealing with a record/object or extended type 
     const tDef = types.get(t.name)!
     if("extends" in tDef && tDef.extends.length == 1) {
-      return ValueOrErrors.Operations.return(converters[(tDef.extends[0] as keyof BuiltInApiConverters)].toAPIRawValue([obj, formState.modifiedByUser] as never))
+      return ValueOrErrors.Operations.Return(converters[(tDef.extends[0] as keyof BuiltInApiConverters)].toAPIRawValue([obj, formState.modifiedByUser] as never))
     }    
     const convertedMap = tDef.fields.mapEntries(([fieldName, fieldType] ) => {
       const revertedFieldName = revertKeyword(fieldName)
@@ -320,10 +311,10 @@ export const toAPIRawValue = <T>(t: Type, types: Map<TypeName, TypeDefinition>,
     })
     if(convertedMap.some((valueOrError) => valueOrError.kind == "errors")) {
       const propertiesWithErrors = convertedMap.filter((valueOrError) => valueOrError.kind == "errors")
-      const namedErrors = propertiesWithErrors.map((value, key) => value.mapErrors(_ => _.map((_: string) => `${key}: ${_}`)))
-      return ValueOrErrors.Operations.all(List<ValueOrErrors<any, string>>(namedErrors.valueSeq().toList()))
+      const namedErrors = propertiesWithErrors.map((value, key) => value.MapErrors(_ => _.map((_: string) => `${key}: ${_}`)))
+      return ValueOrErrors.Operations.All(List<ValueOrErrors<any, string>>(namedErrors.valueSeq().toList()))
     }
-    return ValueOrErrors.Operations.return(convertedMap.map(valueOrError => valueOrError.kind == "value" ? valueOrError.value : valueOrError.errors).toJS())
+    return ValueOrErrors.Operations.Return(convertedMap.map(valueOrError => valueOrError.kind == "value" ? valueOrError.value : valueOrError.errors).toJS())
   }
-  return ValueOrErrors.Operations.return(defaultValue(types, builtIns, injectedPrimitives)(t.value))
+  return ValueOrErrors.Operations.Return(defaultValue(types, builtIns, injectedPrimitives)(t.value))
 }

package/src/forms/domains/parser/domains/validator/state.ts

@@ -161,7 +161,6 @@ export const FormsConfig = {
             errors = errors.push(`type ${typeName} extends non-existent type ${extendedTypeName}`);
         });
         typeDef.fields.forEach((fieldDef, fieldName) => {
-          // TODO - check application args are a valid type (-refs, primtives, lookups, possible here? or may have to do at end) also no undefined
           if (fieldDef.kind == "primitive" && (!builtIns.primitives.has(fieldDef.value) && !injectedPrimitives?.injectedPrimitives.has(fieldDef.value as keyof T) ))
             errors = errors.push(`field ${fieldName} of type ${typeName} is non-existent primitive type ${fieldDef.value}`);
           if (fieldDef.kind == "lookup" && !types.has(fieldDef.name))
@@ -570,8 +569,6 @@ export const FormsConfig = {
           return
         }
         const launcherKind = formsConfig["launchers"][launcherName]["kind"] as Launcher["kind"] | MappingLauncher["kind"]
-          console.log(formsConfig["launchers"][launcherName]["form"])
-          console.log(forms.keySeq().toArray());
         if (forms.has(formsConfig["launchers"][launcherName]["form"]) == false) {
           errors = errors.push(`launcher '${launcherName}' references non-existing form '${formsConfig.launchers[launcherName].form}'`);
           return

package/src/forms/domains/parser/state.tsx

@@ -209,7 +209,7 @@ export const ParseForm = <T,>(
             .mapContext<any>(_ => ({ ..._, label, tooltip }))
         } else { // the list argument is a primitive
           const elementForm = FieldView(fieldConfig, fieldViews, fieldNameToElementViewCategory(formFieldElementRenderers)(fieldName) as any, elementRendererName, elementLabel, elementTooltip, EnumOptionsSources, fieldsOptionsConfig, leafPredicates, injectedPrimitives)
-          const initialFormState = FieldFormState(fieldConfig, fieldViews, fieldNameToElementViewCategory(formFieldElementRenderers)(fieldName) as any, elementRendererName, InfiniteStreamSources, fieldsInfiniteStreamsConfig, injectedPrimitives);
+          const initialFormState = FieldFormState(fieldConfig, fieldViews, fieldNameToElementViewCategory(formFieldElementRenderers)(fieldName) as any, elementRendererName, fieldName, InfiniteStreamSources, fieldsInfiniteStreamsConfig, injectedPrimitives);
           formConfig[fieldName] = ListForm<any, any, any & FormLabel, Unit>(
             { Default: () => initialFormState },
             { Default: () => initialElementValue },
@@ -305,7 +305,7 @@ export type EditLauncherContext<Entity, FormState, ExtraContext> =
       extraContext: ExtraContext,
       containerFormView: any,
       submitButtonWrapper: any
-    }, "api" | "actualForm">
+    }, "api" | "parser" | "actualForm">
 
 export type CreateLauncherContext<Entity, FormState, ExtraContext> =
   Omit<
@@ -477,9 +477,8 @@ export const parseForms =
           get: (id: string) => entityApis.get(launcher.api)(id).then((raw: any) => {
             return fromAPIRawValue({ kind: "lookup", name: parsedForm.formDef.type }, formsConfig.types, builtIns, apiConverters, false, injectedPrimitives)(raw)
           }),
-          update: (id: Guid, value: any, formState: any) => {
-            const raw = toAPIRawValue({ kind: "lookup", name: parsedForm.formDef.type }, formsConfig.types, builtIns, apiConverters, false, injectedPrimitives)(value, formState)
-            return raw.kind == "errors" ? Promise.reject(raw.errors) : entityApis.update(launcher.api)(id, raw.value)  
+          update: (id: any, parsed: any) => {
+            return entityApis.update(launcher.api)(id, parsed)  
           }
         }
         parsedLaunchers.edit = parsedLaunchers.edit.set(
@@ -489,6 +488,7 @@ export const parseForms =
               ({
                 ...parentContext,
                 api: api,
+                parser: (value: any, formState: any) => toAPIRawValue({ kind: "lookup", name: parsedForm.formDef.type }, formsConfig.types, builtIns, apiConverters, false, injectedPrimitives)(value, formState),
                 actualForm: form.withView(containerFormView).mapContext((_: any) => ({ ..._, rootValue: _.value, ...parentContext.extraContext }))
               }) as any)
               .withViewFromProps(props => props.context.submitButtonWrapper)

package/src/forms/domains/primitives/domains/list/template.tsx

@@ -8,44 +8,44 @@ import { ListFieldState, ListFieldView } from "./state";
 
 export const ListForm = <Element, ElementFormState, Context extends FormLabel, ForeignMutationsExpected>(
   ElementFormState: { Default: () => ElementFormState },
-  Element: { Default: () => Element },
+  Element: { Default: () => Element  | undefined},
   elementTemplate: Template<
-    Context & Value<Element> & ElementFormState,
+    Context & Value<Element | undefined> & ElementFormState,
     ElementFormState,
     ForeignMutationsExpected & {
-      onChange: OnChange<Element>;
+      onChange: OnChange<Element | undefined>;
     }>,
-  validation?: BasicFun<List<Element>, Promise<FieldValidation>>,
+  validation?: BasicFun<List<Element | undefined>, Promise<FieldValidation>>,
 ) => {
   const embeddedElementTemplate = (elementIndex:number) =>
       elementTemplate
         .mapForeignMutationsFromProps<ForeignMutationsExpected & {
-          onChange: OnChange<List<Element>>;
+          onChange: OnChange<List<Element| undefined>>;
           add: SimpleCallback<Unit>;
-          remove: SimpleCallback<number>;}>((props): ForeignMutationsExpected & {onChange: OnChange<Element>} => ({
+          remove: SimpleCallback<number>;}>((props): ForeignMutationsExpected & {onChange: OnChange<Element | undefined>} => ({
         ...props.foreignMutations,
         onChange: (elementUpdater, path) => {
-          props.foreignMutations.onChange(Updater((elements:List<Element>) =>
-            elements.update(elementIndex, (_:Element | undefined) => _ == undefined ? _ : elementUpdater(_))), path)
+          props.foreignMutations.onChange(Updater((elements:List<Element | undefined>) =>
+            elements.has(elementIndex) ? elements.update(elementIndex, undefined, elementUpdater) : elements), path)
           props.setState(_ => ({..._,
              modifiedByUser:true,
             })) },
         add: (newElement: Element) => { },
         remove: (elementIndex: number) => { }
       }))
-        .mapContext((_: Context & Value<List<Element>> & ListFieldState<Element, ElementFormState>) : (Context & Value<Element> & ElementFormState) | undefined => {
+        .mapContext((_: Context & Value<List<Element | undefined>> & ListFieldState<Element | undefined, ElementFormState>) : (Context & Value<Element | undefined> & ElementFormState) | undefined => {
+          if(!_.value.has(elementIndex)) return undefined
           const element = _.value.get(elementIndex)
-          if (element == undefined) return undefined
           const elementFormState = _.elementFormStates.get(elementIndex) || ElementFormState.Default()
-          const elementContext : Context & Value<Element> & ElementFormState = ({ ..._, ...elementFormState, value: element })
+          const elementContext : Context & Value<Element | undefined> & ElementFormState = ({ ..._, ...elementFormState, value: element })
           return elementContext
         })
-        .mapState((_:BasicUpdater<ElementFormState>) : Updater<ListFieldState<Element, ElementFormState>> => 
-          ListFieldState<Element, ElementFormState>().Updaters.Core.elementFormStates(
+        .mapState((_:BasicUpdater<ElementFormState>) : Updater<ListFieldState<Element | undefined, ElementFormState>> => 
+          ListFieldState<Element | undefined, ElementFormState>().Updaters.Core.elementFormStates(
             MapRepo.Updaters.upsert(elementIndex, () => ElementFormState.Default(),  _)
           ))
-  return Template.Default<Context & Value<List<Element>> & { disabled: boolean }, ListFieldState<Element, ElementFormState>, ForeignMutationsExpected & { onChange: OnChange<List<Element>>; },
-    ListFieldView<Element, ElementFormState, Context, ForeignMutationsExpected>>(props => <>
+  return Template.Default<Context & Value<List<Element | undefined>> & { disabled: boolean }, ListFieldState<Element | undefined, ElementFormState>, ForeignMutationsExpected & { onChange: OnChange<List<Element | undefined>>; },
+    ListFieldView<Element | undefined, ElementFormState, Context, ForeignMutationsExpected>>(props => <>
       <props.view {...props}
         context={{
           ...props.context,
@@ -54,7 +54,7 @@ export const ListForm = <Element, ElementFormState, Context extends FormLabel, F
           ...props.foreignMutations,
           add: (_) => {
             props.foreignMutations.onChange(
-              ListRepo.Updaters.push(Element.Default()), List()
+              ListRepo.Updaters.push<Element | undefined>(Element.Default()), List()
             )            
           },
           remove: (_) => {
@@ -67,7 +67,7 @@ export const ListForm = <Element, ElementFormState, Context extends FormLabel, F
       />
     </>
     ).any([
-      ValidateRunner<Context & { disabled: boolean }, ListFieldState<Element, ElementFormState>, ForeignMutationsExpected, List<Element>>(
+      ValidateRunner<Context & { disabled: boolean }, ListFieldState<Element | undefined, ElementFormState>, ForeignMutationsExpected, List<Element | undefined>>(
         validation ? _ => validation(_).then(FieldValidationWithPath.Default.fromFieldValidation) : undefined
       ),
     ]);