ballerina-core 1.0.0

package/src/forms/domains/primitives/domains/searchable-infinite-stream/state.ts

@@ -0,0 +1,55 @@
+import { simpleUpdater, BasicUpdater, Updater, SimpleCallback } from "../../../../../../main";
+import { Debounced } from "../../../../../debounced/state";
+import { BasicFun } from "../../../../../fun/state";
+import { InfiniteStreamState } from "../../../../../infinite-data-stream/state";
+import { View } from "../../../../../template/state";
+import { Value } from "../../../../../value/state";
+import { CollectionReference } from "../../../collection/domains/reference/state";
+import { CollectionSelection } from "../../../collection/domains/selection/state";
+import { FormLabel } from "../../../singleton/domains/form-label/state";
+import { OnChange, SharedFormState } from "../../../singleton/state";
+
+
+export type SearchableInfiniteStreamState<Element extends CollectionReference> = 
+  SharedFormState &
+  { searchText: Debounced<Value<string>>; status: "open" | "closed"; stream: InfiniteStreamState<Element>; getChunk: BasicFun<string, InfiniteStreamState<Element>["getChunk"]>; };
+export const SearchableInfiniteStreamState = <Element extends CollectionReference>() => ({
+  Default: (searchText: string, getChunk: BasicFun<string, InfiniteStreamState<Element>["getChunk"]>): SearchableInfiniteStreamState<Element> => ({
+    ...SharedFormState.Default(),
+    searchText: Debounced.Default(Value.Default(searchText)),
+    status: "closed",
+    getChunk,
+    stream: InfiniteStreamState<Element>().Default(10, getChunk(searchText))
+  }),
+  Updaters: {
+    Core: {
+      ...simpleUpdater<SearchableInfiniteStreamState<Element>>()("status"),
+      ...simpleUpdater<SearchableInfiniteStreamState<Element>>()("stream"),
+      ...simpleUpdater<SearchableInfiniteStreamState<Element>>()("searchText"),
+    },
+    Template: {
+      searchText: (_: BasicUpdater<string>): Updater<SearchableInfiniteStreamState<Element>> => SearchableInfiniteStreamState<Element>().Updaters.Core.searchText(
+        Debounced.Updaters.Template.value(
+          Value.Updaters.value(
+            _
+          )
+        )
+      )
+    }
+  }
+});
+export type SearchableInfiniteStreamView<Element extends CollectionReference, Context extends FormLabel, ForeignMutationsExpected> = 
+  View<
+    Context & Value<CollectionSelection<Element>> & SearchableInfiniteStreamState<Element> & {
+      hasMoreValues:boolean
+    }, 
+    SearchableInfiniteStreamState<Element>, 
+    ForeignMutationsExpected & { 
+      onChange: OnChange<CollectionSelection<Element>>; 
+      toggleOpen:SimpleCallback<void>
+      clearSelection:SimpleCallback<void>
+      setSearchText:SimpleCallback<string>
+      select:SimpleCallback<Element>
+      loadMore:SimpleCallback<void>
+      reload:SimpleCallback<void>
+    }>;

package/src/forms/domains/primitives/domains/searchable-infinite-stream/template.tsx

@@ -0,0 +1,114 @@
+import { List } from "immutable";
+import { SimpleCallback, Debounce, InfiniteStreamLoader, id, replaceWith, BasicFun, Synchronize, Unit, ValidateRunner } from "../../../../../../main";
+import { CoTypedFactory } from "../../../../../coroutines/builder";
+import { Debounced } from "../../../../../debounced/state";
+import { InfiniteStreamState } from "../../../../../infinite-data-stream/state";
+import { Template } from "../../../../../template/state";
+import { Value } from "../../../../../value/state";
+import { CollectionReference } from "../../../collection/domains/reference/state";
+import { CollectionSelection } from "../../../collection/domains/selection/state";
+import { FormLabel } from "../../../singleton/domains/form-label/state";
+import { FieldValidation, FieldValidationWithPath, FormValidatorSynchronized, OnChange, ValidationError } from "../../../singleton/state";
+import { SearchableInfiniteStreamState, SearchableInfiniteStreamView } from "./state";
+
+
+export const SearchableInfiniteStreamForm = <Element extends CollectionReference, Context extends FormLabel, ForeignMutationsExpected>(
+  validation:BasicFun<CollectionSelection<Element>, Promise<FieldValidation>>
+) => {
+  const Co = CoTypedFactory<Context & Value<CollectionSelection<Element>>, SearchableInfiniteStreamState<Element>>();
+  const DebouncerCo = CoTypedFactory<Context & { onDebounce: SimpleCallback<void>; } & Value<CollectionSelection<Element>>, SearchableInfiniteStreamState<Element>>();
+  const DebouncedCo = CoTypedFactory<{ onDebounce: SimpleCallback<void>; }, Value<string>>();
+  const debouncer = DebouncerCo.Repeat(
+    DebouncerCo.Seq([
+      Debounce<Value<string>, { onDebounce: SimpleCallback<void>; }>(
+        DebouncedCo.GetState().then(current => DebouncedCo.Do(() => current.onDebounce()))
+          //.SetState(SearchNow.Updaters.reloadsRequested(_ => _ + 1))
+          .then(_ => DebouncedCo.Return("success")),
+        250
+      ).embed(_ => ({ ..._, ..._.searchText }), SearchableInfiniteStreamState<Element>().Updaters.Core.searchText),
+      DebouncerCo.Wait(0)
+    ])
+  );
+  const debouncerRunner = DebouncerCo.Template<ForeignMutationsExpected & { onChange: OnChange<CollectionSelection<Element>>; }>(
+    debouncer,
+    {
+      interval: 15,
+      runFilter: props => Debounced.Operations.shouldCoroutineRun(props.context.searchText)
+    }
+  );
+  const loaderRunner = Co.Template<ForeignMutationsExpected & { onChange: OnChange<CollectionSelection<Element>>; }>(
+    InfiniteStreamLoader<Element>().embed(_ => _.stream, SearchableInfiniteStreamState<Element>().Updaters.Core.stream),
+    {
+      interval: 15,
+      runFilter: props => InfiniteStreamState().Operations.shouldCoroutineRun(props.context.stream)
+    }
+  );
+
+  return Template.Default<Context & Value<CollectionSelection<Element>>, SearchableInfiniteStreamState<Element>, ForeignMutationsExpected & { onChange: OnChange<CollectionSelection<Element>>; },
+    SearchableInfiniteStreamView<Element, Context, ForeignMutationsExpected>>(props => <>
+      <props.view {...props}
+        context={{
+          ...props.context,
+          hasMoreValues: !(props.context.stream.loadedElements.last()?.hasMoreValues == false),
+        }}
+        foreignMutations={{
+          ...props.foreignMutations,
+          toggleOpen: () => props.setState(
+              SearchableInfiniteStreamState<Element>().Updaters.Core.status(
+                replaceWith(
+                  props.context.status == "closed" ? "open" : "closed")
+              ).then(
+                props.context.stream.loadedElements.count() == 0 ?
+                  SearchableInfiniteStreamState<Element>().Updaters.Core.stream(
+                    InfiniteStreamState<Element>().Updaters.Template.loadMore()
+                  )
+                  : id
+              )
+            ),
+          clearSelection: () => {
+            props.foreignMutations.onChange(
+              replaceWith(
+                CollectionSelection<Element>().Default.right("no selection")
+              ), List()
+            )
+          },
+          setSearchText: _ =>
+            props.setState(
+              SearchableInfiniteStreamState<Element>().Updaters.Template.searchText(
+                replaceWith(_)
+              )
+            ),
+          loadMore: () =>
+            props.setState(
+              SearchableInfiniteStreamState<Element>().Updaters.Core.stream(
+                InfiniteStreamState<Element>().Updaters.Template.loadMore()
+              )
+            ),
+          reload: () =>
+            props.setState(
+              SearchableInfiniteStreamState<Element>().Updaters.Template.searchText(
+                replaceWith("")
+              )
+            ),
+          select: _ =>
+            props.foreignMutations.onChange(replaceWith<CollectionSelection<Element>>(CollectionSelection<Element>().Default.left(_)), List()),
+        }}
+      />
+    </>
+    ).any([
+      loaderRunner,
+      debouncerRunner.mapContextFromProps(props => ({
+        ...props.context,
+        onDebounce: () => props.setState(
+          SearchableInfiniteStreamState<Element>().Updaters.Core.stream(
+            InfiniteStreamState<Element>().Updaters.Template.reload(
+              props.context.getChunk(props.context.searchText.value)
+            )
+          )
+        )
+      })),
+      ValidateRunner<Context, SearchableInfiniteStreamState<Element>, ForeignMutationsExpected, CollectionSelection<Element>>(
+        _ => validation(_).then(FieldValidationWithPath.Default.fromFieldValidation)
+      ),
+    ]);
+};

package/src/forms/domains/primitives/domains/searchable-infinite-stream-multiselect/state.ts

@@ -0,0 +1,27 @@
+import { OrderedMap } from "immutable";
+import { Guid, SimpleCallback } from "../../../../../../main";
+import { View } from "../../../../../template/state";
+import { Value } from "../../../../../value/state";
+import { CollectionReference } from "../../../collection/domains/reference/state";
+import { FormLabel } from "../../../singleton/domains/form-label/state";
+import { OnChange } from "../../../singleton/state";
+import { SearchableInfiniteStreamState } from "../searchable-infinite-stream/state";
+
+
+export type InfiniteStreamMultiselectView<Element extends CollectionReference, Context extends FormLabel, ForeignMutationsExpected> = 
+  View<
+    Context & Value<OrderedMap<Guid, Element>> & SearchableInfiniteStreamState<Element> & {
+      hasMoreValues:boolean,
+      isLoading:boolean,
+      availableOptions:Array<Element>
+    }, 
+    SearchableInfiniteStreamState<Element>, 
+    ForeignMutationsExpected & { 
+      onChange: OnChange<OrderedMap<Guid, Element>>; 
+      toggleOpen:SimpleCallback<void>
+      clearSelection:SimpleCallback<void>
+      setSearchText:SimpleCallback<string>
+      toggleSelection:SimpleCallback<Element>
+      loadMore:SimpleCallback<void>
+      reload:SimpleCallback<void>
+  }>;

package/src/forms/domains/primitives/domains/searchable-infinite-stream-multiselect/template.tsx

@@ -0,0 +1,119 @@
+import { List, OrderedMap } from "immutable";
+import { Guid, SimpleCallback, Debounce, InfiniteStreamLoader, CollectionSelection, id, replaceWith, OrderedMapRepo, AsyncState, BasicFun, Synchronize, Unit, ValidateRunner } from "../../../../../../main";
+import { CoTypedFactory } from "../../../../../coroutines/builder";
+import { Debounced } from "../../../../../debounced/state";
+import { InfiniteStreamState } from "../../../../../infinite-data-stream/state";
+import { Template } from "../../../../../template/state";
+import { Value } from "../../../../../value/state";
+import { CollectionReference } from "../../../collection/domains/reference/state";
+import { FormLabel } from "../../../singleton/domains/form-label/state";
+import { FieldValidation, FieldValidationWithPath, FormValidatorSynchronized, OnChange, ValidationError } from "../../../singleton/state";
+import { SearchableInfiniteStreamState } from "../searchable-infinite-stream/state";
+import { InfiniteStreamMultiselectView } from "./state";
+
+
+export const InfiniteMultiselectDropdownForm = <Element extends CollectionReference, Context extends FormLabel, ForeignMutationsExpected>(
+  validation:BasicFun<OrderedMap<Guid, Element>, Promise<FieldValidation>>
+) => {
+  const Co = CoTypedFactory<Context & Value<OrderedMap<Guid, Element>>, SearchableInfiniteStreamState<Element>>();
+  const DebouncerCo = CoTypedFactory<Context & { onDebounce: SimpleCallback<void>; } & Value<OrderedMap<Guid, Element>>, SearchableInfiniteStreamState<Element>>();
+  const DebouncedCo = CoTypedFactory<{ onDebounce: SimpleCallback<void>; }, Value<string>>();
+  const debouncer = DebouncerCo.Repeat(
+    DebouncerCo.Seq([
+      Debounce<Value<string>, { onDebounce: SimpleCallback<void>; }>(
+        DebouncedCo.GetState().then(current => DebouncedCo.Do(() => current.onDebounce()))
+          //.SetState(SearchNow.Updaters.reloadsRequested(_ => _ + 1))
+          .then(_ => DebouncedCo.Return("success")),
+        250
+      ).embed(_ => ({ ..._, ..._.searchText }), SearchableInfiniteStreamState<Element>().Updaters.Core.searchText),
+      DebouncerCo.Wait(0)
+    ])
+  );
+  const debouncerRunner = DebouncerCo.Template<ForeignMutationsExpected & { onChange: OnChange<OrderedMap<Guid, Element>>; }>(
+    debouncer,
+    {
+      interval: 15,
+      runFilter: props => Debounced.Operations.shouldCoroutineRun(props.context.searchText)
+    }
+  );
+  const loaderRunner = Co.Template<ForeignMutationsExpected & { onChange: OnChange<OrderedMap<Guid, Element>>; }>(
+    InfiniteStreamLoader<Element>().embed(_ => _.stream, SearchableInfiniteStreamState<Element>().Updaters.Core.stream),
+    {
+      interval: 15,
+      runFilter: props => InfiniteStreamState().Operations.shouldCoroutineRun(props.context.stream)
+    }
+  );
+
+  return Template.Default<Context & Value<OrderedMap<Guid, Element>>, SearchableInfiniteStreamState<Element>, ForeignMutationsExpected & { onChange: OnChange<OrderedMap<Guid, Element>>; }, InfiniteStreamMultiselectView<Element, Context, ForeignMutationsExpected>>(props => <>
+    <props.view {...props}
+      context={{
+        ...props.context,
+        hasMoreValues: !(props.context.stream.loadedElements.last()?.hasMoreValues == false),
+        isLoading: AsyncState.Operations.isLoading(props.context.stream.loadingMore),
+        availableOptions: props.context.stream.loadedElements.valueSeq().flatMap(chunk =>
+          chunk.data.valueSeq()
+        ).toArray()
+      }}
+      foreignMutations={{
+        ...props.foreignMutations,
+        toggleOpen: () => props.setState(
+            SearchableInfiniteStreamState<Element>().Updaters.Core.status(
+              replaceWith(
+                props.context.status == "closed" ? "open" : "closed")
+            ).then(
+              props.context.stream.loadedElements.count() == 0 ?
+                SearchableInfiniteStreamState<Element>().Updaters.Core.stream(
+                  InfiniteStreamState<Element>().Updaters.Template.loadMore()
+                )
+                : id
+            )
+          ),
+        clearSelection: () => {
+          props.foreignMutations.onChange(
+            OrderedMapRepo.Updaters.clear(), List()
+          )
+        },
+        setSearchText: _ =>
+          props.setState(
+            SearchableInfiniteStreamState<Element>().Updaters.Template.searchText(
+              replaceWith(_)
+            )
+          ),
+        loadMore: () =>
+          props.setState(
+            SearchableInfiniteStreamState<Element>().Updaters.Core.stream(
+              InfiniteStreamState<Element>().Updaters.Template.loadMore()
+            )
+          ),
+        reload: () =>
+          props.setState(
+            SearchableInfiniteStreamState<Element>().Updaters.Template.searchText(
+              replaceWith("")
+            )
+          ),
+        toggleSelection: element =>
+          props.foreignMutations.onChange(
+            props.context.value.has(element.id) ?
+              OrderedMapRepo.Updaters.remove(element.id) :
+              OrderedMapRepo.Updaters.set(element.id, element),
+            List()),
+      }}
+    />
+  </>
+  ).any([
+    loaderRunner,
+    debouncerRunner.mapContextFromProps(props => ({
+      ...props.context,
+      onDebounce: () => props.setState(
+        SearchableInfiniteStreamState<Element>().Updaters.Core.stream(
+          InfiniteStreamState<Element>().Updaters.Template.reload(
+            props.context.getChunk(props.context.searchText.value)
+          )
+        )
+      )
+    })),
+    ValidateRunner<Context, SearchableInfiniteStreamState<Element>, ForeignMutationsExpected, OrderedMap<Guid, Element>>(
+      _ => validation(_).then(FieldValidationWithPath.Default.fromFieldValidation)
+    ),
+  ]);
+};

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

@@ -0,0 +1,12 @@
+import { SimpleCallback, Unit } from "../../../../../../main";
+import { View } from "../../../../../template/state";
+import { Value } from "../../../../../value/state";
+import { FormLabel } from "../../../singleton/domains/form-label/state";
+import { OnChange, SharedFormState } from "../../../singleton/state";
+
+export type StringView<Context extends FormLabel, ForeignMutationsExpected> = 
+  View<
+    Context & Value<string> & SharedFormState, 
+    SharedFormState, 
+    ForeignMutationsExpected & { onChange: OnChange<string>; setNewValue: SimpleCallback<string> }
+  >;

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

@@ -0,0 +1,24 @@
+import { List } from "immutable";
+import { BasicFun, CoTypedFactory, Debounce, Debounced, replaceWith, Synchronize, Unit, ValidateRunner } from "../../../../../../main";
+import { Template } from "../../../../../template/state";
+import { Value } from "../../../../../value/state";
+import { FormLabel } from "../../../singleton/domains/form-label/state";
+import { FieldValidation, FieldValidationWithPath, FormValidatorSynchronized, OnChange, SharedFormState, ValidationError } from "../../../singleton/state";
+import { StringView } from "./state";
+
+
+export const StringForm = <Context extends FormLabel, ForeignMutationsExpected>(
+  validation:BasicFun<string, Promise<FieldValidation>>) => {
+  return Template.Default<Context & Value<string>, SharedFormState, ForeignMutationsExpected & { onChange: OnChange<string>; }, StringView<Context, ForeignMutationsExpected>>(props => <>
+    <props.view {...props}
+      foreignMutations={{
+        ...props.foreignMutations,
+        setNewValue: (_) => props.foreignMutations.onChange(replaceWith(_), List())
+      }} />
+  </>
+  ).any([
+    ValidateRunner<Context, SharedFormState, ForeignMutationsExpected, string>(
+      _ => validation(_).then(FieldValidationWithPath.Default.fromFieldValidation)
+    ),
+  ])
+}

package/src/forms/domains/singleton/domains/descriptors/entity/state.ts

@@ -0,0 +1,9 @@
+import { FieldDescriptor } from "../field/state";
+
+
+export type EntityDescriptor<E, EnumKeys, InfiniteEnumKeys, CustomTypeFields, Context> = {
+  [k in keyof E]: FieldDescriptor<E, EnumKeys, InfiniteEnumKeys, CustomTypeFields, k, Context>;
+};
+export const EntityDescriptor = {
+  Default: <E, EnumKeys, InfiniteEnumKeys, CustomTypeFields, Context>(_: EntityDescriptor<E, EnumKeys, InfiniteEnumKeys, CustomTypeFields, Context>): EntityDescriptor<E, EnumKeys, InfiniteEnumKeys, CustomTypeFields, Context> => _
+};

package/src/forms/domains/singleton/domains/descriptors/field/domains/base/state.ts

@@ -0,0 +1,5 @@
+
+export type BaseConfig = { visible: boolean; disabled: boolean; };
+export const BaseConfig = {
+  Default: (visible?: boolean, disabled?: boolean): BaseConfig => ({ visible: visible ?? true, disabled: disabled ?? false })
+};

package/src/forms/domains/singleton/domains/descriptors/field/domains/boolean/state.ts

@@ -0,0 +1,6 @@
+import { BaseConfig } from "../base/state";
+
+export type BooleanConfig = { kind: "boolean"; } & BaseConfig;
+export const BooleanConfig = {
+  Default: (visible?: boolean, disabled?: boolean): BooleanConfig => ({ kind: "boolean", ...(BaseConfig.Default(visible, disabled)) })
+};

package/src/forms/domains/singleton/domains/descriptors/field/domains/custom/state.ts

@@ -0,0 +1,21 @@
+import { SimpleCallback, BasicUpdater } from "../../../../../../../../../main";
+import { SingletonFormWritableState } from "../../../../../state";
+import { BaseConfig } from "../base/state";
+
+
+export type CustomTypeConfig<E, EnumKeys, InfiniteEnumKeys, CustomTypeFields, k extends (keyof E) & (keyof CustomTypeFields), Context> =
+  {
+    kind: "custom"; k: k;
+    render: (props: {
+      context:Context,
+      state:CustomTypeFields[k],
+      entityValue: E;
+      fieldValue: E[k];
+      onChange: SimpleCallback<E[k]>;
+      setState: SimpleCallback<BasicUpdater<SingletonFormWritableState<E, EnumKeys, InfiniteEnumKeys, CustomTypeFields>>>;
+    }) => JSX.Element;
+  } & BaseConfig;
+export const CustomTypeConfig = {
+  Default: <E, EnumKeys, InfiniteEnumKeys, CustomTypeFields, k extends (keyof E) & (keyof CustomTypeFields), Context>(
+    k: k, render: CustomTypeConfig<E, EnumKeys, InfiniteEnumKeys, CustomTypeFields, k, Context>["render"], visible?: boolean, disabled?: boolean): CustomTypeConfig<E, EnumKeys, InfiniteEnumKeys, CustomTypeFields, k, Context> => ({ kind: "custom", k, render, visible: visible ?? true, disabled: disabled ?? false })
+};

package/src/forms/domains/singleton/domains/descriptors/field/domains/date/state.ts

@@ -0,0 +1,6 @@
+import { BaseConfig } from "../base/state";
+
+export type DateConfig = { kind: "date"; } & BaseConfig;
+export const DateConfig = {
+  Default: (visible?: boolean, disabled?: boolean): DateConfig => ({ kind: "date", ...(BaseConfig.Default(visible, disabled)) })
+};

package/src/forms/domains/singleton/domains/descriptors/field/domains/enum/state.ts

@@ -0,0 +1,7 @@
+import { SmallIdentifiable } from "../../../../../../../../../main";
+import { BaseConfig } from "../base/state";
+
+export type EnumConfig<V> = { kind: "enum"; choices: Array<SmallIdentifiable & { displayName: string; value: V; }>; } & BaseConfig;
+export const EnumConfig = {
+  Default: <V>(choices: EnumConfig<V>["choices"], visible?: boolean, disabled?: boolean): EnumConfig<V> => ({ kind: "enum", choices, ...(BaseConfig.Default(visible, disabled)) })
+};

package/src/forms/domains/singleton/domains/descriptors/field/domains/infinite-enum/state.ts

@@ -0,0 +1,8 @@
+import { SmallIdentifiable } from "../../../../../../../../../main";
+import { InfiniteStreamState } from "../../../../../../../../infinite-data-stream/state";
+import { BaseConfig } from "../base/state";
+
+export type InfiniteEnumConfig<V extends SmallIdentifiable> = { kind: "infinite-enum"; getChunk: InfiniteStreamState<V>["getChunk"]; } & BaseConfig;
+export const InfiniteEnumConfig = {
+  Default: <V extends SmallIdentifiable>(getChunk: InfiniteStreamState<V>["getChunk"], visible?: boolean, disabled?: boolean): InfiniteEnumConfig<V> => ({ kind: "infinite-enum", getChunk, ...(BaseConfig.Default(visible, disabled)) })
+};

package/src/forms/domains/singleton/domains/descriptors/field/domains/number/state.ts

@@ -0,0 +1,7 @@
+import { BaseConfig } from "../base/state";
+
+export type NumberConfig = { kind: "number"; } & BaseConfig;
+export const NumberConfig = {
+  Default: (visible?: boolean, disabled?: boolean): NumberConfig => ({ kind: "number", ...(BaseConfig.Default(visible, disabled)) })
+};
+

package/src/forms/domains/singleton/domains/descriptors/field/domains/string/state.ts

@@ -0,0 +1,7 @@
+import { BaseConfig } from "../base/state";
+
+
+export type StringConfig = { kind: "string"; } & BaseConfig;
+export const StringConfig = {
+  Default: (visible?: boolean, disabled?: boolean): StringConfig => ({ kind: "string", ...(BaseConfig.Default(visible, disabled)) })
+};

package/src/forms/domains/singleton/domains/descriptors/field/state.ts

@@ -0,0 +1,16 @@
+import { SmallIdentifiable } from "../../../../../../../main";
+import { NumberConfig } from "./domains/number/state";
+import { StringConfig } from "./domains/string/state";
+import { BooleanConfig } from "./domains/boolean/state";
+import { DateConfig } from "./domains/date/state";
+import { EnumConfig } from "./domains/enum/state";
+import { InfiniteEnumConfig } from "./domains/infinite-enum/state";
+import { CustomTypeConfig } from "./domains/custom/state";
+
+
+export type FieldDescriptor<E, EnumKeys, InfiniteEnumKeys, CustomTypeFields, k extends keyof E, Context> = 
+  k extends keyof CustomTypeFields ? 
+    CustomTypeConfig<E, EnumKeys, InfiniteEnumKeys, CustomTypeFields, k, Context> : 
+    k extends EnumKeys ? EnumConfig<E[k]> : 
+    k extends InfiniteEnumKeys ? E[k] extends SmallIdentifiable ? InfiniteEnumConfig<E[k]> : 
+    { kind: "error - infinite enum requires 'extends Identifiable'"; } : E[k] extends number ? NumberConfig : E[k] extends string ? StringConfig : E[k] extends string ? StringConfig : E[k] extends boolean ? BooleanConfig : E[k] extends Date ? DateConfig : { kind: "error - type not supported "; };

package/src/forms/domains/singleton/domains/descriptors/form/state.ts

@@ -0,0 +1,13 @@
+import { Template } from "../../../../../../template/state";
+import { SingletonFormReadonlyContext, SingletonFormWritableState, SingletonFormForeignMutationsExpected } from "../../../state";
+import { FieldViews } from "../../../views/field-views";
+import { EntityDescriptor } from "../entity/state";
+
+export type FormDefinition<Entity, EnumKeys, InfiniteEnumKeys, CustomTypeFields, Context> = {
+  entityDescriptor: EntityDescriptor<Entity, EnumKeys, InfiniteEnumKeys, CustomTypeFields, Context>;
+  fieldOrder: Array<keyof Entity>;
+};
+export type FormTemplateAndDefinition<Entity, EnumKeys, InfiniteEnumKeys, CustomTypeFields, Context> = {
+  template: Template<
+    SingletonFormReadonlyContext<Entity, EnumKeys, InfiniteEnumKeys, CustomTypeFields, Context> & SingletonFormWritableState<Entity, EnumKeys, InfiniteEnumKeys, CustomTypeFields>, SingletonFormWritableState<Entity, EnumKeys, InfiniteEnumKeys, CustomTypeFields>, SingletonFormForeignMutationsExpected<Entity, EnumKeys, InfiniteEnumKeys>, FieldViews>;
+} & FormDefinition<Entity, EnumKeys, InfiniteEnumKeys, CustomTypeFields, Context>;

package/src/forms/domains/singleton/domains/form-label/state.ts

@@ -0,0 +1,2 @@
+
+export type FormLabel = { label: string; };

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

@@ -0,0 +1,87 @@
+import { List, OrderedMap, OrderedSet } from "immutable"
+import { BasicUpdater, id, BasicPredicate, SimpleCallback, Unit, Debounced, Synchronized, unit, replaceWith, CoTypedFactory, Debounce, Synchronize, BasicFun } from "../../../../main"
+import { Template, View } from "../../../template/state"
+import { Value } from "../../../value/state"
+
+export type ToPathUnions<a> = a[keyof a]
+export type Paths<Entity, NestedPaths = Unit> = {
+  [f in keyof Entity]:
+    f extends keyof NestedPaths ?
+      [f, ToPathUnions<NestedPaths[f]>]
+    : [f]
+}
+
+// type OtherNestedThing = { x:boolean, y:string }
+// type Address = { city:string, street:string, number:number, other:OtherNestedThing }
+// type Person = { name:string, surname:string, birthday:Date, address:Address, other:OtherNestedThing }
+// type OtherNestedThingPaths = Paths<OtherNestedThing, Unit>
+// type AddressPaths = Paths<Address, { other:OtherNestedThingPaths }>
+// type PersonPaths = ToPathUnions<Paths<Person, { address:AddressPaths, other:OtherNestedThingPaths }>>
+// const f = (_:PersonPaths) => {
+//   if (_[0] == "name") return
+//   if (_[0] == "surname") return
+//   if (_[0] == "birthday") return
+//   if (_[0] == "address") {
+//     _[1][0] == "city"
+//     if (_[1][0] == "other") {
+//       _[1][1][0] == "x"
+//     }
+//     return
+//   }
+//   _[1][0] == "x"
+// }
+
+export type ValidationError = string
+export type FieldValidation = Array<ValidationError>
+export type Path = Array<string>
+export type ValidationErrorWithPath = [Path, ValidationError]
+export type FieldValidationWithPath = Array<ValidationErrorWithPath>
+export const FieldValidationWithPath = {
+  Default:{
+    fromFieldValidation:(_:FieldValidation) : FieldValidationWithPath => 
+      _.map(_ => ([[], _])),      
+  }
+}
+export type FormValidatorSynchronized = Synchronized<Unit, FieldValidationWithPath>
+export type SharedFormState = { modifiedByUser: boolean, validation: Debounced<FormValidatorSynchronized> }
+export const SharedFormState = {
+  Default: (): SharedFormState => ({
+    modifiedByUser: false,
+    // start the validation so that it immediately runs and registers the first errors such as missing values and such
+    validation: Debounced.Updaters.Template.value<FormValidatorSynchronized>(Synchronized.Updaters.value(replaceWith(unit)))(Debounced.Default(Synchronized.Default(unit)))
+  })
+}
+export type EntityFormState<Entity, Fields extends (keyof Entity) & (keyof FieldStates), FieldStates, Context, ForeignMutationsExpected> =
+  { [f in Fields]: FieldStates[f] & SharedFormState } & SharedFormState
+export type EntityFormContext<Entity, Fields extends (keyof Entity) & (keyof FieldStates), FieldStates, Context, ForeignMutationsExpected> =
+  Context & EntityFormState<Entity, Fields, FieldStates, Context, ForeignMutationsExpected> & { visibleFields: OrderedMap<Fields, BasicPredicate<Context>> } & Value<Entity>
+export type OnChange<Entity> = (updater: BasicUpdater<Entity>, path: List<string>) => void
+export type EntityFormForeignMutationsExpected<Entity, Fields extends (keyof Entity) & (keyof FieldStates), FieldStates, Context, ForeignMutationsExpected> =
+  ForeignMutationsExpected & { onChange: OnChange<Entity> }
+
+export type FieldTemplates<Entity, Fields extends (keyof Entity) & (keyof FieldStates), FieldStates, Context, ForeignMutationsExpected> = {
+  [f in Fields]: EmbeddedFieldTemplate<Entity, Fields, FieldStates, Context, ForeignMutationsExpected>
+}
+
+export type EntityFormView<Entity, Fields extends (keyof Entity) & (keyof FieldStates), FieldStates, Context, ForeignMutationsExpected> =
+  View<EntityFormContext<Entity, Fields, FieldStates, Context, ForeignMutationsExpected>, EntityFormState<Entity, Fields, FieldStates, Context, ForeignMutationsExpected>, EntityFormForeignMutationsExpected<Entity, Fields, FieldStates, Context, ForeignMutationsExpected>, {
+    EmbeddedFields: FieldTemplates<Entity, Fields, FieldStates, Context, ForeignMutationsExpected>,
+    VisibleFieldKeys: OrderedSet<Fields>
+  }>
+export type EntityFormTemplate<Entity, Fields extends (keyof Entity) & (keyof FieldStates), FieldStates, Context, ForeignMutationsExpected> =
+  Template<
+    EntityFormContext<Entity, Fields, FieldStates, Context, ForeignMutationsExpected>,
+    EntityFormState<Entity, Fields, FieldStates, Context, ForeignMutationsExpected>,
+    EntityFormForeignMutationsExpected<Entity, Fields, FieldStates, Context, ForeignMutationsExpected>,
+    EntityFormView<Entity, Fields, FieldStates, Context, ForeignMutationsExpected>
+  >
+export type EmbeddedFieldTemplate<Entity, Fields extends (keyof Entity) & (keyof FieldStates), FieldStates, Context, ForeignMutationsExpected> =
+  Template<
+    EntityFormContext<Entity, Fields, FieldStates, Context, ForeignMutationsExpected>,
+    EntityFormState<Entity, Fields, FieldStates, Context, ForeignMutationsExpected>,
+    EntityFormForeignMutationsExpected<Entity, Fields, FieldStates, Context, ForeignMutationsExpected>
+  >
+
+export type FormStateFromEntity<E, S> = {
+  [f in keyof E]: f extends keyof S ? S[f] & SharedFormState : SharedFormState
+} & SharedFormState