ballerina-core 1.0.0 → 1.0.2

package/main.ts

@@ -87,8 +87,11 @@ export * from "./src/forms/domains/primitives/domains/searchable-infinite-stream
 export * from "./src/forms/domains/primitives/domains/searchable-infinite-stream/template"
 export * from "./src/forms/domains/primitives/domains/searchable-infinite-stream-multiselect/state"
 export * from "./src/forms/domains/primitives/domains/searchable-infinite-stream-multiselect/template"
+export * from "./src/forms/domains/singleton/domains/mapping/state"
+export * from "./src/forms/domains/singleton/domains/mapping/template"
 export * from "./src/forms/domains/parser/state"
 export * from "./src/forms/domains/parser/domains/validator/state"
+export * from "./src/forms/domains/parser/domains/merger/state"
 export * from "./src/forms/domains/launcher/domains/edit/state"
 export * from "./src/forms/domains/launcher/domains/edit/template"
 export * from "./src/forms/domains/launcher/domains/edit/coroutines/runner"

package/package.json

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

package/readme.md

@@ -0,0 +1,122 @@
+# Ballerina 🩰
+
+Welcome to _ballerina_, the effortlessly elegant functional programming framework for frontend web development, with a particular but non-exclusive preference for React.
+
+
+## Quick start
+Everything in Ballerina 🩰 is based on the separation of code into units called _domains_.
+
+Create a Typescript/React project however you want (I like to use rspack but you can use whatever you prefer).
+
+Head over to the sources, and create all the necessary files and directories for a new domain (this is just a best practice and it avoids merge conflicts in the long run):
+
+```
+mkdir helloWorld
+cd helloWorld
+touch state.ts
+touch template.tsx
+mkdir coroutines
+touch coroutines/runner.ts
+```
+
+Let's define the state of our domain in `state.ts`:
+
+```ts
+import { simpleUpdater } from "ballerina-core"
+
+export type HelloWorldContext = { greeting:string }
+export type HelloWorldState = { counter:number, toggle:boolean }
+export const HelloWorldState = {
+  Default:() : HelloWorldState => ({
+    counter:0,
+    toggle:false
+  }),
+  Updaters:{
+    ...simpleUpdater<HelloWorldState>()("counter"),
+    ...simpleUpdater<HelloWorldState>()("toggle")
+  }
+}
+```
+
+Let's define a simple automation in `coroutine/runner.ts`:
+
+```ts
+import { CoTypedFactory, replaceWith, Unit } from "ballerina-core"
+import { HelloWorldContext, HelloWorldState } from "../state"
+import { Range } from "immutable"
+
+const Co = CoTypedFactory<HelloWorldContext, HelloWorldState>()
+export const helloWorldRunner =
+  Co.Template<Unit>(
+    Co.Repeat(
+      Co.Seq([
+        Co.SetState(
+          HelloWorldState.Updaters.counter(replaceWith(0))
+        ),
+        Co.Wait(250),
+        Co.For(Range(0, 3))(
+          i => Co.Seq([
+            Co.SetState(
+              HelloWorldState.Updaters.counter(_ => _ + 1)
+            ),
+            Co.Wait(250)
+          ])
+        )
+      ])
+    )
+  )
+```
+
+Let's put something ugly on the screen in `template.tsx`:
+
+```tsx
+import { Template, Unit } from "ballerina-core";
+import { HelloWorldContext, HelloWorldState } from "./state";
+import { helloWorldRunner } from "./coroutines/runner";
+
+export const HelloWorldTemplate = 
+  Template.Default<HelloWorldContext & HelloWorldState, HelloWorldState, Unit>(props => 
+    <>
+      <p>{props.context.greeting}</p>
+      <p>Counter: {props.context.counter}</p>
+      <button 
+        onClick={() => props.setState(HelloWorldState.Updaters.toggle(_ => !_))}>
+          Toggle {props.context.toggle ? "off" : "on"}
+      </button>
+    </>
+  ).any([
+    helloWorldRunner
+  ])
+```
+
+Finally, let's render this as a top-level stateful domain from the React entry point (which file depends on the template you used):
+
+```tsx
+import { useState } from "react";
+import "./App.css";
+import { HelloWorldState } from "./domains/helloWorld/state";
+import { HelloWorldTemplate } from "./domains/helloWorld/template";
+import { unit } from "ballerina-core";
+
+export const App = (props: {}) => {
+	const [helloWorld, setHelloWorld] = useState(HelloWorldState.Default())
+	return <>
+		<HelloWorldTemplate 
+			context={{
+				greeting:"Hello!",
+				...helloWorld
+			}}
+			setState={setHelloWorld}
+			foreignMutations={unit}
+			view={unit}
+		/>
+	</>
+}
+```
+
+Head over to the page and you will see an animated `counter` value that changes on its own as well as a button you can interact with.
+
+We have barely scratched the surface of all you can do with Ballerina 🩰 though.
+
+
+If you want to know more, head over to [the official git repo](https://github.com/giuseppemag/ballerina) and check out the samples and the official documentation.

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

@@ -0,0 +1,9 @@
+import { FormValidationError } from "../validator/state"
+
+export const FormsConfigMerger = {
+  Default:{
+    merge:(formsConfigs:any, errors:Array<FormValidationError>) : [any, Array<FormValidationError>] => {
+      return null!
+    }
+  }
+}

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

@@ -1,5 +1,5 @@
 import { Set, Map, OrderedMap } from "immutable";
-import { BoolExpr, Sum } from "../../../../../../main";
+import { BoolExpr, FormsConfigMerger, Sum } from "../../../../../../main";
 
 
 export type FieldName = string;
@@ -12,7 +12,7 @@ export type TypeDefinition = {
 export type Type = {
   kind: "lookup"; name: TypeName;
 } | {
-  kind: "primitive"; value: "string" | "number" | "boolean" | "Date" | "CollectionReference";
+  kind: "primitive"; value: "string" | "number" | "maybeBoolean" | "boolean" | "Date" | "CollectionReference";
 } | {
   kind: "application"; value: TypeName; args: Array<TypeName>;
 };
@@ -65,6 +65,7 @@ export type BuiltIns = {
   generics: Set<string>;
   renderers: {
     BooleanViews: Set<string>;
+    MaybeBooleanViews: Set<string>;
     NumberViews: Set<string>;
     StringViews: Set<string>;
     DateViews: Set<string>;
@@ -80,6 +81,13 @@ export const FormsConfig = {
   Default: {
     validateAndParseAPIResponse: (builtIns: BuiltIns) => (formsConfig: any): FormValidationResult => {
       let errors: Array<FormValidationError> = [];
+      if (Array.isArray(formsConfig)) {
+        alert("formsConfig is an array!")
+        const merged = FormsConfigMerger.Default.merge(formsConfig, errors)
+        formsConfig = merged[0]
+        errors = merged[0]
+      }
+
       let types: Map<TypeName, TypeDefinition> = Map();
       if ("types" in formsConfig == false) {
         errors.push("the formsConfig does not contain a 'types' field");
@@ -133,9 +141,9 @@ export const FormsConfig = {
           if (fieldDef.kind == "primitive" && !builtIns.primitives.includes(fieldDef.value))
             errors.push(`field ${fieldName} of type ${typeName} is non-existent primitive type ${fieldDef.value}`);
           if (fieldDef.kind == "lookup" && !types.has(fieldDef.name))
-            errors.push(`field ${fieldName} of type ${typeName} is non-existent defined type ${fieldDef.name}`);
+            errors.push(`field ${fieldName} of type ${typeName} is non-existent type ${fieldDef.name}`);
           if (fieldDef.kind == "application" && !builtIns.generics.includes(fieldDef.value))
-            errors.push(`field ${fieldName} of type ${typeName} applies non-existent generic  type ${fieldDef.value}`);
+            errors.push(`field ${fieldName} of type ${typeName} applies non-existent generic type ${fieldDef.value}`);
           if (fieldDef.kind == "application" && fieldDef.args.some(argType => !builtIns.primitives.includes(argType) && !types.has(argType)))
             errors.push(`field ${fieldName} of type ${typeName} applies non-existent type arguments ${JSON.stringify(fieldDef.args.filter(argType => !builtIns.primitives.has(argType) && !types.has(argType)))}`);
           if (fieldDef.kind == "application" && fieldDef.value == "SingleSelection") {
@@ -240,7 +248,12 @@ export const FormsConfig = {
               }
               const fieldTypeDef = formTypeDef?.fields.get(fieldName)
               if (fieldTypeDef?.kind == "primitive") {
-                if (fieldTypeDef.value == "boolean") {
+                if (fieldTypeDef.value == "maybeBoolean") {
+                  // alert(JSON.stringify(fieldConfig["renderer"]))
+                  // alert(JSON.stringify(builtIns.renderers.MaybeBooleanViews))
+                  if (!builtIns.renderers.MaybeBooleanViews.has(fieldConfig["renderer"]))
+                    errors.push(`field ${fieldName} of form ${formName} references non-existing ${fieldTypeDef.value} 'renderer' ${fieldConfig["renderer"]}`);
+                } else if (fieldTypeDef.value == "boolean") {
                   if (!builtIns.renderers.BooleanViews.has(fieldConfig["renderer"]))
                     errors.push(`field ${fieldName} of form ${formName} references non-existing ${fieldTypeDef.value} 'renderer' ${fieldConfig["renderer"]}`);
                 } else if (fieldTypeDef.value == "number") {

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

@@ -1,9 +1,9 @@
 import { Collection, Map, OrderedMap, OrderedSet, Set } from "immutable";
-import { BoolExpr, Unit, PromiseRepo, Guid, LeafPredicatesEvaluators, Predicate, FormsConfig, BuiltIns, FormDef, Sum, BasicFun, Template, unit, EditFormState, EditFormTemplate, ApiErrors, CreateFormTemplate, EntityFormTemplate, SharedFormState } from "../../../../main";
+import { BoolExpr, Unit, PromiseRepo, Guid, LeafPredicatesEvaluators, Predicate, FormsConfig, BuiltIns, FormDef, Sum, BasicFun, Template, unit, EditFormState, EditFormTemplate, ApiErrors, CreateFormTemplate, EntityFormTemplate, SharedFormState, CreateFormState, Entity, EditFormContext, CreateFormContext } from "../../../../main";
 import { Value } from "../../../value/state";
 import { CollectionReference } from "../collection/domains/reference/state";
 import { CollectionSelection } from "../collection/domains/selection/state";
-import { BooleanForm } from "../primitives/domains/boolean/template";
+import { BooleanForm, MaybeBooleanForm } from "../primitives/domains/boolean/template";
 import { DateFormState } from "../primitives/domains/date/state";
 import { DateForm } from "../primitives/domains/date/template";
 import { EnumMultiselectForm } from "../primitives/domains/enum-multiselect/template";
@@ -25,47 +25,51 @@ const parseOptions = (leafPredicates: any, options: any) => {
 
 export const FieldView = //<Context, FieldViews extends DefaultFieldViews, EnumFieldConfigs extends {}, EnumSources extends {}>() => <ViewType extends keyof FieldViews, ViewName extends keyof FieldViews[ViewType]>
   (fieldViews: any, viewType: any, viewName: any, fieldName: string, enumFieldConfigs: any, enumSources: any, leafPredicates: any): any => // FieldView<Context, FieldViews, ViewType, ViewName> =>
-    viewType == "BooleanViews" ?
-      BooleanForm<any & FormLabel, Unit>(_ => PromiseRepo.Default.mock(() => []))
+    viewType == "MaybeBooleanViews" ?
+      MaybeBooleanForm<any & FormLabel, Unit>(_ => PromiseRepo.Default.mock(() => []))
         .withView(((fieldViews as any)[viewType] as any)[viewName]() as any)
         .mapContext<any & SharedFormState & Value<boolean>>(_ => ({ ..._, label: fieldName })) as any
-      : viewType == "DateViews" ?
-        DateForm<any & FormLabel, Unit>(_ => PromiseRepo.Default.mock(() => []))
+      : viewType == "BooleanViews" ?
+        BooleanForm<any & FormLabel, Unit>(_ => PromiseRepo.Default.mock(() => []))
           .withView(((fieldViews as any)[viewType] as any)[viewName]() as any)
-          .mapContext<any & DateFormState & Value<Date>>(_ => ({ ..._, label: fieldName })) as any
-        : viewType == "NumberViews" ?
-          NumberForm<any & FormLabel, Unit>(_ => PromiseRepo.Default.mock(() => []))
+          .mapContext<any & SharedFormState & Value<boolean>>(_ => ({ ..._, label: fieldName })) as any
+        : viewType == "DateViews" ?
+          DateForm<any & FormLabel, Unit>(_ => PromiseRepo.Default.mock(() => []))
             .withView(((fieldViews as any)[viewType] as any)[viewName]() as any)
-            .mapContext<any & SharedFormState & Value<number>>(_ => ({ ..._, label: fieldName })) as any
-          : viewType == "StringViews" ?
-            StringForm<any & FormLabel, Unit>(_ => PromiseRepo.Default.mock(() => []))
+            .mapContext<any & DateFormState & Value<Date>>(_ => ({ ..._, label: fieldName })) as any
+          : viewType == "NumberViews" ?
+            NumberForm<any & FormLabel, Unit>(_ => PromiseRepo.Default.mock(() => []))
               .withView(((fieldViews as any)[viewType] as any)[viewName]() as any)
-              .mapContext<any & SharedFormState & Value<string>>(_ => ({ ..._, label: fieldName })) as any
-            : viewType == "EnumViews" ?
-              EnumForm<any & FormLabel & BaseEnumContext<any, CollectionReference>, Unit, CollectionReference>(_ => PromiseRepo.Default.mock(() => []))
+              .mapContext<any & SharedFormState & Value<number>>(_ => ({ ..._, label: fieldName })) as any
+            : viewType == "StringViews" ?
+              StringForm<any & FormLabel, Unit>(_ => PromiseRepo.Default.mock(() => []))
                 .withView(((fieldViews as any)[viewType] as any)[viewName]() as any)
-                .mapContext<any & EnumFormState<any & BaseEnumContext<any, CollectionReference>, CollectionReference> & Value<CollectionSelection<CollectionReference>>>(_ => ({
-                  ..._, label: fieldName, getOptions: () => ((enumFieldConfigs as any)((enumSources as any)[fieldName]) as Promise<any>).then(options => parseOptions(leafPredicates, options))
-                })) as any
-              : viewType == "EnumMultiselectViews" ?
-                EnumMultiselectForm<any & FormLabel & BaseEnumContext<any, CollectionReference>, Unit, CollectionReference>(_ => PromiseRepo.Default.mock(() => []))
+                .mapContext<any & SharedFormState & Value<string>>(_ => ({ ..._, label: fieldName })) as any
+              : viewType == "EnumViews" ?
+                EnumForm<any & FormLabel & BaseEnumContext<any, CollectionReference>, Unit, CollectionReference>(_ => PromiseRepo.Default.mock(() => []))
                   .withView(((fieldViews as any)[viewType] as any)[viewName]() as any)
-                  .mapContext<any & EnumFormState<any & BaseEnumContext<any, CollectionReference>, CollectionReference> & Value<OrderedMap<Guid, CollectionReference>>>(_ => ({
+                  .mapContext<any & EnumFormState<any & BaseEnumContext<any, CollectionReference>, CollectionReference> & Value<CollectionSelection<CollectionReference>>>(_ => ({
                     ..._, label: fieldName, getOptions: () => ((enumFieldConfigs as any)((enumSources as any)[fieldName]) as Promise<any>).then(options => parseOptions(leafPredicates, options))
                   })) as any
-                : viewType == "InfiniteStreamViews" ?
-                  SearchableInfiniteStreamForm<CollectionReference, any & FormLabel, Unit>(_ => PromiseRepo.Default.mock(() => []))
+                : viewType == "EnumMultiselectViews" ?
+                  EnumMultiselectForm<any & FormLabel & BaseEnumContext<any, CollectionReference>, Unit, CollectionReference>(_ => PromiseRepo.Default.mock(() => []))
                     .withView(((fieldViews as any)[viewType] as any)[viewName]() as any)
-                    .mapContext<any & SearchableInfiniteStreamState<CollectionReference> & Value<CollectionSelection<CollectionReference>>>(_ => ({ ..._, label: fieldName })) as any
-                  : viewType == "InfiniteStreamMultiselectViews" ?
-                    InfiniteMultiselectDropdownForm<CollectionReference, any & FormLabel, Unit>(_ => PromiseRepo.Default.mock(() => []))
+                    .mapContext<any & EnumFormState<any & BaseEnumContext<any, CollectionReference>, CollectionReference> & Value<OrderedMap<Guid, CollectionReference>>>(_ => ({
+                      ..._, label: fieldName, getOptions: () => ((enumFieldConfigs as any)((enumSources as any)[fieldName]) as Promise<any>).then(options => parseOptions(leafPredicates, options))
+                    })) as any
+                  : viewType == "InfiniteStreamViews" ?
+                    SearchableInfiniteStreamForm<CollectionReference, any & FormLabel, Unit>(_ => PromiseRepo.Default.mock(() => []))
                       .withView(((fieldViews as any)[viewType] as any)[viewName]() as any)
-                      .mapContext<any & FormLabel & SharedFormState & SearchableInfiniteStreamState<CollectionReference> & Value<OrderedMap<Guid, CollectionReference>>>(_ => ({ ..._, label: fieldName })) as any
-                    : `error: the view for ${viewType as string}::${viewName as string} cannot be found`;
+                      .mapContext<any & SearchableInfiniteStreamState<CollectionReference> & Value<CollectionSelection<CollectionReference>>>(_ => ({ ..._, label: fieldName })) as any
+                    : viewType == "InfiniteStreamMultiselectViews" ?
+                      InfiniteMultiselectDropdownForm<CollectionReference, any & FormLabel, Unit>(_ => PromiseRepo.Default.mock(() => []))
+                        .withView(((fieldViews as any)[viewType] as any)[viewName]() as any)
+                        .mapContext<any & FormLabel & SharedFormState & SearchableInfiniteStreamState<CollectionReference> & Value<OrderedMap<Guid, CollectionReference>>>(_ => ({ ..._, label: fieldName })) as any
+                      : `error: the view for ${viewType as string}::${viewName as string} cannot be found`;
 
 export const FieldFormState = //<Context, FieldViews extends DefaultFieldViews, InfiniteStreamSources extends {}, InfiniteStreamConfigs extends {}>() => <ViewType extends keyof FieldViews, ViewName extends keyof FieldViews[ViewType]>
   (fieldViews: any, viewType: any, viewName: any, fieldName: string, InfiniteStreamSources: any, infiniteStreamConfigs: any): any => {
-    if (viewType == "BooleanViews" || viewType == "NumberViews" || viewType == "StringViews")
+    if (viewType == "MaybeBooleanViews" || viewType == "BooleanViews" || viewType == "NumberViews" || viewType == "StringViews")
       return SharedFormState.Default();
     if (viewType == "DateViews")
       return DateFormState.Default("");
@@ -116,7 +120,6 @@ export const ParseForm = (
       otherForms.get(viewName)?.initialFormState ??
       FieldFormState(fieldViews, fieldNameToViewCategory(fieldName) as any, (fieldsViewsConfig as any)[fieldName], fieldName, InfiniteStreamSources, fieldsInfiniteStreamsConfig);
     if (typeof initialFormState[fieldName] == "string") {
-      formConfig[fieldName] = (props: any) => <>Error: field {fieldName} with {viewName} could not be instantiated</>
       throw `cannot resolve initial state ${viewName} of field ${fieldName}`
     }
   });
@@ -151,10 +154,11 @@ export const parseVisibleFields = (
 
 export const builtInsFromFieldViews = (fieldViews: any): BuiltIns => {
   let builtins: BuiltIns = {
-    "primitives": Set(["string", "number", "boolean", "Date", "CollectionReference"]),
+    "primitives": Set(["string", "number", "boolean", "maybeBoolean", "Date", "CollectionReference"]),
     "generics": Set(["SingleSelection", "Multiselection"]),
     "renderers": {
       "BooleanViews": Set(),
+      "MaybeBooleanViews": Set(),
       "DateViews": Set(),
       "EnumMultiselectViews": Set(),
       "EnumViews": Set(),
@@ -175,9 +179,38 @@ export const builtInsFromFieldViews = (fieldViews: any): BuiltIns => {
   return builtins
 }
 
+export type EditLauncherContext<Entity, FormState, ExtraContext> =
+  Omit<
+    EditFormContext<Entity, FormState> &
+    EditFormState<Entity, FormState> & {
+      extraContext: ExtraContext,
+      containerFormView: any
+    }, "api" | "actualForm">
+
+export type CreateLauncherContext<Entity, FormState, ExtraContext> =
+  Omit<
+    CreateFormContext<Entity, FormState> &
+    CreateFormState<Entity, FormState> & {
+      extraContext: ExtraContext,
+      containerFormView: any
+      submitButtonWrapper: any
+    }, "api" | "actualForm">
+
 export type ParsedLaunchers = {
-  create:Map<string, { form: Template<any, any, Unit>, initialState:any, actualForm: EntityFormTemplate<any, any, any, any, any> }>,
-  edit:Map<string, { form: Template<any, any, Unit>, initialState:any, actualForm: EntityFormTemplate<any, any, any, any, any> }>,
+  create: Map<string, <Entity, FormState, ExtraContext, Context extends CreateLauncherContext<Entity, FormState, ExtraContext>>() =>
+    {
+      form:
+      Template<CreateLauncherContext<Entity, FormState, ExtraContext> & CreateFormState<Entity, FormState>,
+        CreateFormState<Entity, FormState>, Unit>,
+      initialState: CreateFormState<Entity, FormState>
+    }>,
+  edit: Map<string, <Entity, FormState, ExtraContext, Context extends EditLauncherContext<Entity, FormState, ExtraContext>>() =>
+    {
+      form:
+      Template<EditLauncherContext<Entity, FormState, ExtraContext> & EditFormState<Entity, FormState>,
+        EditFormState<Entity, FormState>, Unit>,
+      initialState: EditFormState<Entity, FormState>
+    }>,
 }
 export type ParsedForms = Map<string, ParsedForm & { form: EntityFormTemplate<any, any, any, any, any> }>
 export type FormParsingErrors = Array<string>
@@ -186,10 +219,10 @@ export type StreamName = string
 export type InfiniteStreamSources = BasicFun<StreamName, SearchableInfiniteStreamState<CollectionReference>["getChunk"]>
 export type EntityName = string
 export type EntityApis = {
-  create:BasicFun<EntityName, BasicFun<any, Promise<Unit>>>
-  default:BasicFun<EntityName, BasicFun<Unit,Promise<any>>>
-  update:BasicFun<EntityName, BasicFun<any,Promise<ApiErrors>>>
-  get:BasicFun<EntityName, BasicFun<Guid,Promise<any>>>
+  create: BasicFun<EntityName, BasicFun<any, Promise<Unit>>>
+  default: BasicFun<EntityName, BasicFun<Unit, Promise<any>>>
+  update: BasicFun<EntityName, BasicFun<any, Promise<ApiErrors>>>
+  get: BasicFun<EntityName, BasicFun<Guid, Promise<any>>>
 }
 export type EnumName = string
 export type EnumOptionsSources = BasicFun<EnumName, Promise<Array<[CollectionReference, BoolExpr<Unit>]>>>
@@ -199,16 +232,16 @@ export const parseForms =
     fieldViews: any,
     infiniteStreamSources: InfiniteStreamSources,
     enumOptionsSources: EnumOptionsSources,
-    entityApis:EntityApis,
+    entityApis: EntityApis,
     leafPredicates: LeafPredicates) =>
     (formsConfig: FormsConfig):
       FormParsingResult => {
       let errors: FormParsingErrors = []
       let seen = Set<string>()
       let formProcessingOrder = OrderedSet<string>()
-      let parsedLaunchers:ParsedLaunchers = {
-        create:Map(),
-        edit:Map(),
+      let parsedLaunchers: ParsedLaunchers = {
+        create: Map(),
+        edit: Map(),
       }
       let parsedForms: ParsedForms = Map()
       const traverse = (formDef: FormDef) => {
@@ -268,16 +301,16 @@ export const parseForms =
           update: entityApis.update(launcher.api)
         }
         parsedLaunchers.edit = parsedLaunchers.edit.set(
-          launcherName, {
-            form:EditFormTemplate<any, any>().mapContext((parentContext:any) => 
-            ({
-              ...parentContext,
-              api: api,
-              actualForm:form.withView(parentContext.containerFormView).mapContext((_: any) => ({ ..._, rootValue: _.value, ...parentContext.extraContext }))
-            })),
-            initialState:EditFormState<any, any>().Default(initialState),
-            actualForm:form,
-          }          
+          launcherName,
+          <Entity, FormState, ExtraContext, Context extends EditLauncherContext<Entity, FormState, ExtraContext>>() => ({
+            form: EditFormTemplate<Entity, FormState>().mapContext((parentContext: Context) =>
+              ({
+                ...parentContext,
+                api: api,
+                actualForm: form.withView(parentContext.containerFormView).mapContext((_: any) => ({ ..._, rootValue: _.value, ...parentContext.extraContext }))
+              }) as any),
+            initialState: EditFormState<Entity, FormState>().Default(initialState),
+          })
         )
       })
 
@@ -290,22 +323,22 @@ export const parseForms =
           default: entityApis.default(launcher.api)
         }
         parsedLaunchers.create = parsedLaunchers.create.set(
-          launcherName, {
-            form:CreateFormTemplate<any, any>().mapContext((parentContext:any) => 
-            ({
-              ...parentContext,
-              api: api,
-              actualForm:form.withView(parentContext.containerFormView).mapContext((_: any) => ({ ..._, rootValue: _.value, ...parentContext.extraContext }))
-            }))
+          launcherName,
+          <Entity, FormState, ExtraContext, Context extends CreateLauncherContext<Entity, FormState, ExtraContext>>() => ({
+            form: CreateFormTemplate<Entity, FormState>().mapContext((parentContext: Context) =>
+              ({
+                ...parentContext,
+                api: api,
+                actualForm: form.withView(parentContext.containerFormView).mapContext((_: any) => ({ ..._, rootValue: _.value, ...parentContext.extraContext }))
+              }) as any)
               .withViewFromProps(props => props.context.submitButtonWrapper)
               .mapForeignMutationsFromProps(props => props.foreignMutations as any),
-            initialState:EditFormState<any, any>().Default(initialState),
-            actualForm:form,
-          }          
+            initialState: CreateFormState<any, any>().Default(initialState),
+            actualForm: form,
+          })
         )
       })
 
       if (errors.length > 0) return Sum.Default.right(errors)
       return Sum.Default.left(parsedLaunchers)
     }
-    

package/src/forms/domains/primitives/domains/boolean/state.ts

@@ -11,3 +11,10 @@ export type BooleanView<Context extends FormLabel, ForeignMutationsExpected> =
     SharedFormState, 
     ForeignMutationsExpected & { onChange: OnChange<boolean>; setNewValue: SimpleCallback<boolean> }
   >;
+
+export type MaybeBooleanView<Context extends FormLabel, ForeignMutationsExpected> = 
+  View<
+    Context & Value<boolean | undefined> & SharedFormState, 
+    SharedFormState, 
+    ForeignMutationsExpected & { onChange: OnChange<boolean | undefined>; setNewValue: SimpleCallback<boolean | undefined> }
+  >;

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

@@ -1,5 +1,5 @@
 import { List } from "immutable";
-import { BasicFun, BooleanView, CoTypedFactory, Debounce, Debounced, replaceWith, Synchronize, Unit, ValidateRunner } from "../../../../../../main";
+import { BasicFun, BooleanView, CoTypedFactory, Debounce, Debounced, MaybeBooleanView, replaceWith, Synchronize, Unit, ValidateRunner } from "../../../../../../main";
 import { Template } from "../../../../../template/state";
 import { Value } from "../../../../../value/state";
 import { FormLabel } from "../../../singleton/domains/form-label/state";
@@ -22,3 +22,20 @@ export const BooleanForm = <Context extends FormLabel, ForeignMutationsExpected>
     ),
   ]);
 }
+
+export const MaybeBooleanForm = <Context extends FormLabel, ForeignMutationsExpected>(
+  validation: BasicFun<boolean | undefined, Promise<FieldValidation>>
+) => {
+  return Template.Default<Context & Value<boolean | undefined>, SharedFormState, ForeignMutationsExpected & { onChange: OnChange<boolean | undefined>; }, MaybeBooleanView<Context, ForeignMutationsExpected>>(props => <>
+    <props.view {...props}
+      foreignMutations={{
+        ...props.foreignMutations,
+        setNewValue: (_) => props.foreignMutations.onChange(replaceWith(_), List())
+      }} />
+  </>
+  ).any([
+    ValidateRunner<Context, SharedFormState, ForeignMutationsExpected, boolean | undefined>(
+      _ => validation(_).then(FieldValidationWithPath.Default.fromFieldValidation)
+    ),
+  ]);
+}

package/src/forms/domains/singleton/domains/mapping/state.ts

@@ -0,0 +1,113 @@
+import { OrderedMap } from "immutable";
+import { Guid, Unit } from "../../../../../../main";
+import { BasicFun } from "../../../../../fun/state";
+import { CollectionSelection } from "../../../collection/domains/selection/state";
+
+
+export type UntypedPath = Array<string | number | symbol>;
+export type MappingPaths<Entity> = {
+  [field in keyof Entity]: Entity[field] extends (string | boolean | number | undefined | Date | CollectionSelection<infer _> | OrderedMap<Guid, infer _>) ? UntypedPath : MappingPaths<Entity[field]>;
+};
+
+export type MappingBuilder<Source, Target, mappedTargetFields extends keyof Target> =
+  (<field extends Exclude<keyof Target, mappedTargetFields>>(field: field) => Target[field] extends (string | boolean | number | undefined | Date | CollectionSelection<infer _> | OrderedMap<Guid, infer _>) ? BasicFun<
+    BasicFun<
+      PathBuilder<Source>, PathBuilder<Target[field]>
+    >, MappingBuilder<Source, Target, mappedTargetFields | field>> : BasicFun<
+      MappingBuilder<Source, Target[field], keyof Target[field]>, MappingBuilder<Source, Target, mappedTargetFields | field>>) & { kind: "mappingBuilder"; paths: MappingPaths<Pick<Target, mappedTargetFields>>; };
+
+export type PathBuilder<Entity> =
+  (<field extends keyof Entity>(field: field) => PathBuilder<Entity[field]>) & {
+    path: UntypedPath;
+  };
+
+export const PathBuilder = {
+  Default: <Entity,>(path: UntypedPath): PathBuilder<Entity> => Object.assign(
+    <field extends keyof Entity>(field: field): PathBuilder<Entity[field]> => PathBuilder.Default<Entity[field]>([...path, field]),
+    {
+      path: path,
+      kind: "pathBuilder"
+    }
+  )
+};
+
+export const MappingBuilder = {
+  Default: <Source, Target, mappedTargetFields extends keyof Target = never>(paths: MappingPaths<Pick<Target, mappedTargetFields>>): MappingBuilder<Source, Target, mappedTargetFields> => Object.assign(
+    <field extends keyof Target>(field: field): any => ((_: MappingBuilder<Source, Unit, never> | BasicFun<
+      PathBuilder<Source>, PathBuilder<Target[field]>>
+    ): MappingBuilder<Source, Target, mappedTargetFields | field> => {
+      if ("kind" in _ == false || _.kind != "mappingBuilder") {
+        const fieldPathBuilder = _ as BasicFun<PathBuilder<Source>, PathBuilder<Target[field]>>;
+        const pathToField = fieldPathBuilder(PathBuilder.Default<Source>([])).path;
+        const extendedPaths: MappingPaths<Pick<Target, mappedTargetFields | field>> = {
+          ...paths,
+          [field]: pathToField
+        } as any;
+        const remainingMappingBuilder = MappingBuilder.Default<Source, Target, mappedTargetFields | field>(extendedPaths);
+        return remainingMappingBuilder;
+      }
+      const fieldEntityMappingBuilder = _ as MappingBuilder<Source, Unit, never>;
+      const extendedPaths: MappingPaths<Pick<Target, mappedTargetFields | field>> = {
+        ...paths,
+        [field]: fieldEntityMappingBuilder.paths
+      } as any;
+      const remainingMappingBuilder = MappingBuilder.Default<Source, Target, mappedTargetFields | field>(extendedPaths);
+      return remainingMappingBuilder;
+    }),
+    {
+      paths: paths,
+      kind: "mappingBuilder" as const
+    }
+  )
+};
+
+export type Mapping<Source, Target> = {
+  from: BasicFun<Source, Target>;
+  to: BasicFun<[Source, Target], Source>;
+  pathFrom: BasicFun<Array<string>, Array<string>>;
+};
+const dynamicLookup = (e: any, path: UntypedPath): any => path.length <= 0 ? e : dynamicLookup(e[path[0]], path.slice(1));
+const dynamicAssignment = (e: any, v: any, path: UntypedPath): any => {
+  if (path.length <= 0) return v;
+  if (path.length <= 1) {
+    return { ...e, [path[0]]: v };
+  }
+  return { ...e, [path[0]]: dynamicAssignment(e[path[0]], v, path.slice(1)) };
+};
+export const Mapping = {
+  Default: <Source, Target>(completedBuilder: MappingBuilder<Source, Target, keyof Target>): Mapping<Source, Target> => ({
+    from: s => {
+      const traversePaths = (paths: MappingPaths<any>) => {
+        const result_t = {} as any;
+        Object.keys(paths).forEach(_ => {
+          const field_t = _ as keyof Target;
+          if (Array.isArray(paths[field_t])) {
+            const pathToFieldT = paths[field_t] as UntypedPath;
+            result_t[field_t] = dynamicLookup(s, pathToFieldT);
+          } else {
+            result_t[field_t] = traversePaths(paths[field_t]);
+          }
+        });
+        return result_t;
+      };
+      return traversePaths(completedBuilder.paths);
+    },
+    to: ([s, t]) => {
+      let result_s = s;
+      const traversePaths = (t: any, paths: MappingPaths<any>) => {
+        Object.keys(paths).forEach(_ => {
+          const field_t = _ as keyof Target;
+          if (Array.isArray(paths[field_t])) {
+            result_s = dynamicAssignment(result_s, t[field_t], paths[field_t]);
+          } else {
+            traversePaths(t[field_t], paths[field_t]);
+          }
+        });
+      };
+      traversePaths(t, completedBuilder.paths);
+      return result_s;
+    },
+    pathFrom: (pathInTarget: Array<string>): Array<string> => dynamicLookup(completedBuilder.paths, pathInTarget),
+  }),
+};
+

package/src/forms/domains/singleton/domains/mapping/template.tsx

@@ -0,0 +1,30 @@
+import { List } from "immutable";
+import { Template } from "../../../../../template/state";
+import { Value } from "../../../../../value/state";
+import { EntityFormContext, EntityFormState, EntityFormForeignMutationsExpected, OnChange, EntityFormView, EntityFormTemplate } from "../../state";
+import { Mapping } from "./state";
+
+
+export type MappedEntityFormTemplate<SourceEntity, Entity, FieldStates, ExtraContext, ExtraForeignMutationsExpected> = Template<
+  Omit<EntityFormContext<Entity, (keyof Entity) & (keyof FieldStates), FieldStates, ExtraContext, ExtraForeignMutationsExpected>, "value"> & Value<SourceEntity>, EntityFormState<Entity, (keyof Entity) & (keyof FieldStates), FieldStates, ExtraContext, ExtraForeignMutationsExpected>, Omit<EntityFormForeignMutationsExpected<Entity, (keyof Entity) & (keyof FieldStates), FieldStates, ExtraContext, ExtraForeignMutationsExpected>, "onChange"> & { onChange: OnChange<SourceEntity>; }, EntityFormView<Entity, (keyof Entity) & (keyof FieldStates), FieldStates, ExtraContext, ExtraForeignMutationsExpected>
+>;
+
+export const MappedEntityFormTemplate = <SourceEntity, Entity, FieldStates, ExtraContext, ExtraForeignMutationsExpected>(
+  mapping: Mapping<SourceEntity, Entity>,
+  form: EntityFormTemplate<
+    Entity, (keyof Entity) & (keyof FieldStates), FieldStates, ExtraContext, ExtraForeignMutationsExpected>
+): MappedEntityFormTemplate<
+  SourceEntity, Entity, FieldStates, ExtraContext, ExtraForeignMutationsExpected> => form
+    .mapContext((_: Omit<EntityFormContext<Entity, (keyof Entity) & (keyof FieldStates), FieldStates, ExtraContext, ExtraForeignMutationsExpected>, "value"> & Value<SourceEntity>) => ({ ..._, value: mapping.from(_.value) }) as any)
+    .mapForeignMutations((_: any) => ({
+      ..._,
+      onChange: (u, path) => {
+        _.onChange(
+          (current: any) => mapping.to([
+            current,
+            u(mapping.from(current))
+          ]),
+          List(mapping.pathFrom(path.toArray()))
+        );
+      }
+    }));

package/src/forms/domains/singleton/template.tsx

@@ -35,7 +35,7 @@ export const Form = <Entity, FieldStates, Context, ForeignMutationsExpected>() =
                     props.foreignMutations.onChange((current: Entity): Entity => ({
                       ...current,
                       [field]: _(current[field])
-                    }), path.push(field as string)),
+                    }), path.unshift(field as string)),
                     0)
                 }
               }))