ballerina-core 1.0.2 → 1.0.3

package/main.ts

@@ -90,14 +90,19 @@ export * from "./src/forms/domains/primitives/domains/searchable-infinite-stream
 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/template"
+export * from "./src/forms/domains/parser/coroutines/runner"
 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"
 export * from "./src/forms/domains/launcher/domains/create/state"
 export * from "./src/forms/domains/launcher/domains/create/template"
 export * from "./src/forms/domains/launcher/domains/create/coroutines/runner"
+export * from "./src/forms/domains/launcher/domains/merger/state"
+export * from "./src/forms/domains/launcher/coroutines/runner"
+export * from "./src/forms/domains/launcher/state"
+export * from "./src/forms/domains/launcher/template"
 
 // import { simpleUpdater, simpleUpdaterWithChildren } from "./src/fun/domains/updater/domains/simpleUpdater/state"
 // import { Updater } from "./src/fun/domains/updater/state"

package/package.json

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

package/src/async/domains/mirroring/domains/collection/coroutines/synchronizers.ts

@@ -249,8 +249,22 @@ export const collectionEntityUpdater = <Collections, CollectionMutations, WholeC
   Collection<Collections[k]>().Updaters.Template.entityValue(id, u)
 ));
 
+export type CollectionMutationArgumentComparators<Collections, CollectionMutations> = {
+  [k in keyof Collections & keyof CollectionMutations]: {[_ in keyof CollectionMutations[k]]: MutationArgumentComparator<CollectionMutations[k][_]>};
+};
+
+export type WholeCollectionMutationArgumentComparators<Collections, WholeCollectionMutations> = {
+  [k in keyof Collections & keyof WholeCollectionMutations]: {[_ in keyof WholeCollectionMutations[k]]: MutationArgumentComparator<WholeCollectionMutations[k][_]>};
+};
+
 export type InsertionPosition = { kind: "after", id: Guid } | { kind: "before", id: Guid } | { kind: "at the end" } | { kind: "at the beginning" }
 
+export type ComparisonResult = ">" | "<" | "==";
+
+export type MutationArgumentComparator<T> = BasicFun<[T, T], ComparisonResult>;
+
+export const withTrivialComparator = <f, ma>(_: f): [f, MutationArgumentComparator<ma>] => [_, (_) => "=="];
+
 export type SynchronizableCollectionEntity<Context, Collections, CollectionMutations, WholeCollectionMutations, SynchronizedEntities, k extends (keyof Collections) & (keyof CollectionMutations) & (keyof WholeCollectionMutations)> = {
   entityName: k,
   // default: BasicFun<void, CollectionEntity<Collections[k]>>,
@@ -265,10 +279,16 @@ export type SynchronizableCollectionEntity<Context, Collections, CollectionMutat
   // reload: () =>
   //   Coroutine<Context & Synchronized<Unit, OrderedMap<Guid, CollectionEntity<Collections[k]>>>, Synchronized<Unit, OrderedMap<Guid, CollectionEntity<Collections[k]>>>, Unit>,
 } & {
-  [_ in keyof (CollectionMutations[k])]: BasicFun<CollectionMutations[k][_], Coroutine<Context & Synchronized<Value<Synchronized<Unit, Collections[k]>>, Unit>, Synchronized<Value<Synchronized<Unit, Collections[k]>>, Unit>, Unit>>
+  [_ in keyof (CollectionMutations[k])]: [
+    BasicFun<CollectionMutations[k][_], Coroutine<Context & Synchronized<Value<Synchronized<Unit, Collections[k]>>, Unit>, Synchronized<Value<Synchronized<Unit, Collections[k]>>, Unit>, Unit>>,
+    MutationArgumentComparator<CollectionMutations[k][_]>,
+  ]
 } & {
   wholeMutations:{
-    [_ in keyof (WholeCollectionMutations[k])]: BasicFun<WholeCollectionMutations[k][_], Coroutine<Context & Synchronized<Unit, OrderedMap<Guid, CollectionEntity<Collections[k]>>>, Synchronized<Unit, OrderedMap<Guid, CollectionEntity<Collections[k]>>>, Unit>>
+    [_ in keyof (WholeCollectionMutations[k])]: [
+      BasicFun<WholeCollectionMutations[k][_], Coroutine<Context & Synchronized<Unit, OrderedMap<Guid, CollectionEntity<Collections[k]>>>, Synchronized<Unit, OrderedMap<Guid, CollectionEntity<Collections[k]>>>, Unit>>,
+      MutationArgumentComparator<WholeCollectionMutations[k][_]>
+    ]
   }
 }
 
@@ -284,7 +304,9 @@ export const collectionSynchronizationContext = <Context, Collections, Collectio
     CollectionDirtyCheckers<Collections, CollectionMutations, WholeCollectionMutations>,
     CollectionDirtySetters<Context, Collections, CollectionMutations, WholeCollectionMutations, SynchronizedEntities>,
     CollectionUpdaters<Collections, CollectionMutations, WholeCollectionMutations, SynchronizedEntities>,
-    SynchronizableEntityDescriptor<Context, Collections, CollectionMutations, WholeCollectionMutations, SynchronizedEntities>
+    SynchronizableEntityDescriptor<Context, Collections, CollectionMutations, WholeCollectionMutations, SynchronizedEntities>,
+    CollectionMutationArgumentComparators<Collections, CollectionMutations>,
+    CollectionMutationArgumentComparators<Collections, WholeCollectionMutations>,
   ] => {
   let synchronizers: CollectionSynchronizers<Context, Collections, CollectionMutations, WholeCollectionMutations> = {} as any
   Object.keys(entityDescriptors).forEach(k_s => {
@@ -307,28 +329,63 @@ export const collectionSynchronizationContext = <Context, Collections, Collectio
       (synchronizers[k] as any)["wholeMutations"][field] = (mutationArg:any) => (entityDescriptors[k]["wholeMutations"] as any)[field](mutationArg)
     })
   })
-  let loaders: CollectionLoaders<Context, Collections, CollectionMutations, WholeCollectionMutations, SynchronizedEntities> = {} as any
+  const loaders: CollectionLoaders<Context, Collections, CollectionMutations, WholeCollectionMutations, SynchronizedEntities> = {} as any
   Object.keys(entityDescriptors).forEach(k_s => {
     const k = k_s as (keyof Collections) & (keyof CollectionMutations) & (keyof WholeCollectionMutations)
     loaders[k] = collectionEntityLoader<Context, Collections, CollectionMutations, WholeCollectionMutations, SynchronizedEntities>(synchronizers)(k, entityDescriptors[k].id, entityDescriptors[k].narrowing, entityDescriptors[k].widening, entityDescriptors[k].dependees)
   })
-  let dirtyCheckers: CollectionDirtyCheckers<Collections, CollectionMutations, WholeCollectionMutations> = {} as any
+  const dirtyCheckers: CollectionDirtyCheckers<Collections, CollectionMutations, WholeCollectionMutations> = {} as any
   Object.keys(entityDescriptors).forEach(k_s => {
     const k = k_s as (keyof Collections) & (keyof CollectionMutations) & (keyof WholeCollectionMutations)
     dirtyCheckers[k] = Fun(collectionCheckNotDirty<Collections, CollectionMutations, WholeCollectionMutations>())
   })
-  let dirtySetters: CollectionDirtySetters<Context, Collections, CollectionMutations, WholeCollectionMutations, SynchronizedEntities> = {} as any
+  const dirtySetters: CollectionDirtySetters<Context, Collections, CollectionMutations, WholeCollectionMutations, SynchronizedEntities> = {} as any
   Object.keys(entityDescriptors).forEach(k_s => {
     const k = k_s as (keyof Collections) & (keyof CollectionMutations) & (keyof WholeCollectionMutations)
     dirtySetters[k] =
       collectionDirtySetter<Context, Collections, CollectionMutations, WholeCollectionMutations, SynchronizedEntities>()
         (k, entityDescriptors[k].narrowing, entityDescriptors[k].widening)
   })
-  let updaters: CollectionUpdaters<Collections, CollectionMutations, WholeCollectionMutations, SynchronizedEntities> = {} as any
+  const updaters: CollectionUpdaters<Collections, CollectionMutations, WholeCollectionMutations, SynchronizedEntities> = {} as any
   Object.keys(entityDescriptors).forEach(k_s => {
     const k = k_s as (keyof Collections) & (keyof CollectionMutations) & (keyof WholeCollectionMutations)
     updaters[k] = collectionEntityUpdater<Collections, CollectionMutations, WholeCollectionMutations, SynchronizedEntities>()(entityDescriptors[k].widening)
   })
-
-  return [loaders, dirtyCheckers, dirtySetters, updaters, entityDescriptors]
+  const mutationComparators: CollectionMutationArgumentComparators<Collections, CollectionMutations> = {} as any;
+  Object.keys(entityDescriptors).forEach((k_s) => {
+    const k = k_s as (keyof Collections) & (keyof CollectionMutations) & (keyof WholeCollectionMutations);
+    mutationComparators[k] = {} as any;
+    Object.keys(entityDescriptors[k]).forEach((field) => {
+      if (
+        field != "entityName" &&
+        field != "narrowing" &&
+        field != "widening" &&
+        field != "dependees" &&
+        field != "add" &&
+        field != "remove" &&
+        field != "default" &&
+        field != "reload"
+      )
+        (mutationComparators[k] as any)[field] = (entityDescriptors[k] as any)[field][1]
+    });
+  });
+  const wholeMutationComparators: WholeCollectionMutationArgumentComparators<Collections, WholeCollectionMutations> = {} as any;
+  Object.keys(entityDescriptors).forEach((k_s) => {
+    const k = k_s as (keyof Collections) & (keyof CollectionMutations) & (keyof WholeCollectionMutations);
+    wholeMutationComparators[k] = {} as any;
+    Object.keys(entityDescriptors[k]).forEach((field) => {
+      if (
+        field != "entityName" &&
+        field != "narrowing" &&
+        field != "widening" &&
+        field != "dependees" &&
+        field != "add" &&
+        field != "remove" &&
+        field != "default" &&
+        field != "reload"
+      )
+        (wholeMutationComparators[k] as any)[field] = (entityDescriptors[k] as any)[field][1];
+    });
+  });
+  return [loaders, dirtyCheckers, dirtySetters, updaters, entityDescriptors, mutationComparators, wholeMutationComparators]
 }

package/src/async/domains/mirroring/domains/singleton/coroutines/synchronizers.ts

@@ -1,4 +1,4 @@
-import { Unit, replaceWith, BasicUpdater, Updater, Value, AsyncState, unit } from "../../../../../../../main";
+import { Unit, replaceWith, BasicUpdater, Updater, Value, AsyncState, unit, MutationArgumentComparator } from "../../../../../../../main";
 import { CoTypedFactory } from "../../../../../../coroutines/builder";
 import { Coroutine } from "../../../../../../coroutines/state";
 import { Debounced, DirtyStatus } from "../../../../../../debounced/state";
@@ -35,6 +35,10 @@ export type SingletonLoaders<Context, Singletons, SingletonMutations, Synchroniz
     Coroutine<Context & SynchronizedEntities, SynchronizedEntities, SynchronizationResult>;
 };
 
+export type SingletonMutationArgumentComparators<Singletons, SingletonMutation> = {
+  [k in (keyof Singletons) & (keyof SingletonMutation)]: {[_ in keyof SingletonMutation[k]]: MutationArgumentComparator<SingletonMutation[k][_]>};
+};
+
 export const singletonEntityLoader = <Context, Singletons, SingletonMutations, SynchronizedEntities>(
   synchronizers: SingletonSynchronizers<Context, Singletons, SingletonMutations>) => <k extends (keyof Singletons) & (keyof SingletonMutations)>(
     k: k, narrowing_k: BasicFun<SynchronizedEntities, Singleton<Singletons[k]>>,
@@ -147,7 +151,10 @@ export type SynchronizableSingletonEntity<Context, Singletons, SingletonMutation
   dependees: Array<Coroutine<Context & SynchronizedEntities, SynchronizedEntities, SynchronizationResult>>,
   // reload: Coroutine<Context & Synchronized<Unit, Singletons[k]>, Synchronized<Unit, Singletons[k]>, Unit>,
 } & {
-  [_ in keyof (SingletonMutations[k])]: BasicFun<SingletonMutations[k][_], Coroutine<Context & Synchronized<Value<Synchronized<Unit, Singletons[k]>>, Unit>, Synchronized<Value<Synchronized<Unit, Singletons[k]>>, Unit>, Unit>>
+  [_ in keyof (SingletonMutations[k])]: [
+    BasicFun<SingletonMutations[k][_], Coroutine<Context & Synchronized<Value<Synchronized<Unit, Singletons[k]>>, Unit>, Synchronized<Value<Synchronized<Unit, Singletons[k]>>, Unit>, Unit>>,
+    MutationArgumentComparator<SingletonMutations[k][_]>
+  ]
 }
 
 export type SynchronizableEntityDescriptors<Context, Singletons, SingletonMutations, SynchronizedEntities> = {
@@ -163,9 +170,10 @@ export const singletonSynchronizationContext = <Context, Singletons, SingletonMu
     SingletonDirtyCheckers<Singletons, SingletonMutations>,
     SingletonDirtySetters<Context, Singletons, SingletonMutations, SynchronizedEntities>,
     SingletonUpdaters<Singletons, SingletonMutations, SynchronizedEntities>,
-    SynchronizableEntityDescriptors<Context, Singletons, SingletonMutations, SynchronizedEntities>
+    SynchronizableEntityDescriptors<Context, Singletons, SingletonMutations, SynchronizedEntities>,
+    SingletonMutationArgumentComparators<Singletons, SingletonMutations>,
   ] => {
-  let synchronizers: SingletonSynchronizers<Context, Singletons, SingletonMutations> = {} as any
+  const synchronizers: SingletonSynchronizers<Context, Singletons, SingletonMutations> = {} as any
   Object.keys(entityDescriptors).forEach(k_s => {
     const k = k_s as (keyof Singletons) & (keyof SingletonMutations)
 
@@ -176,7 +184,7 @@ export const singletonSynchronizationContext = <Context, Singletons, SingletonMu
         (synchronizers[k] as any)[field] = (mutationArg:any) => insideEntitySynchronizedAndDebounced((entityDescriptors[k] as any)[field](mutationArg)) as any
     })
   })
-  let loaders: SingletonLoaders<Context, Singletons, SingletonMutations, SynchronizedEntities> = {} as any
+  const loaders: SingletonLoaders<Context, Singletons, SingletonMutations, SynchronizedEntities> = {} as any
   Object.keys(entityDescriptors).forEach(k_s => {
     const k = k_s as (keyof Singletons) & (keyof SingletonMutations)
     loaders[k] = singletonEntityLoader<Context, Singletons, SingletonMutations, SynchronizedEntities>(synchronizers)(k, entityDescriptors[k].narrowing, entityDescriptors[k].widening, entityDescriptors[k].dependees)
@@ -193,24 +201,41 @@ export const singletonSynchronizationContext = <Context, Singletons, SingletonMu
   //   reloaders[k] = singletonEntityReloader<Context, Singletons, SingletonMutations, SynchronizedEntities>(reloadSynchronizers)(k, entityDescriptors[k].narrowing, entityDescriptors[k].widening, entityDescriptors[k].dependees)
   // })
 
-  let dirtyCheckers: SingletonDirtyCheckers<Singletons, SingletonMutations> = {} as any
+  const dirtyCheckers: SingletonDirtyCheckers<Singletons, SingletonMutations> = {} as any
   Object.keys(entityDescriptors).forEach(k_s => {
     const k = k_s as (keyof Singletons) & (keyof SingletonMutations)
     dirtyCheckers[k] = Fun(singletonCheckNotDirty<Singletons, SingletonMutations>())
   })
-  let dirtySetters: SingletonDirtySetters<Context, Singletons, SingletonMutations, SynchronizedEntities> = {} as any
+  const dirtySetters: SingletonDirtySetters<Context, Singletons, SingletonMutations, SynchronizedEntities> = {} as any
   Object.keys(entityDescriptors).forEach(k_s => {
     const k = k_s as (keyof Singletons) & (keyof SingletonMutations)
     dirtySetters[k] = singletonDirtySetter<Context, Singletons, SingletonMutations, SynchronizedEntities>()(
       k, entityDescriptors[k].narrowing, entityDescriptors[k].widening
     )
   })
-  let updaters: SingletonUpdaters<Singletons, SingletonMutations, SynchronizedEntities> = {} as any
+  const updaters: SingletonUpdaters<Singletons, SingletonMutations, SynchronizedEntities> = {} as any
   Object.keys(entityDescriptors).forEach(k_s => {
     const k = k_s as (keyof Singletons) & (keyof SingletonMutations)
     updaters[k] = singletonEntityUpdater<Singletons, SingletonMutations, SynchronizedEntities>()(entityDescriptors[k].widening)
   })
-
-  return [loaders, /*reloaders,*/ dirtyCheckers, dirtySetters, updaters, entityDescriptors]
+  const mutationComparators: SingletonMutationArgumentComparators<Singletons, SingletonMutations> = {} as any;
+  Object.keys(entityDescriptors).forEach((k_s) => {
+    const k = k_s as (keyof Singletons) & (keyof SingletonMutations)
+    mutationComparators[k] = {} as any;
+    Object.keys(entityDescriptors[k]).forEach((field) => {
+      if (
+        field != "entityName" &&
+        field != "narrowing" &&
+        field != "widening" &&
+        field != "dependees" &&
+        field != "add" &&
+        field != "remove" &&
+        field != "default" &&
+        field != "reload"
+      )
+      (mutationComparators[k] as any)[field] = (entityDescriptors[k] as any)[field][1];
+    });
+  });
+  return [loaders, /*reloaders,*/ dirtyCheckers, dirtySetters, updaters, entityDescriptors, mutationComparators]
 }
 

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

@@ -0,0 +1,57 @@
+import { FormRunnerErrorsTemplate, id, replaceWith, Sum } from "../../../../../main"
+import { AsyncState } from "../../../../async/state"
+import { CoTypedFactory } from "../../../../coroutines/builder"
+import { FormRunnerContext, FormRunnerForeignMutationsExpected, FormRunnerState } from "../state"
+
+export const FormRunnerLoader = () => {
+  const Co = CoTypedFactory<FormRunnerContext, FormRunnerState>()
+
+  //   const MaybePersonFromConfigForm = parsedFormsConfig.kind == "l" ?
+  // 	parsedFormsConfig.value.mappings.get("person-from-config") ?? undefined : undefined
+  // const PersonFromConfigForm =
+  // 	MaybePersonFromConfigForm != undefined ? MaybePersonFromConfigForm<any, any, any, any>()
+  // 		: PersonShowFormSetupErrors(validatedFormsConfig, parsedFormsConfig)
+  return Co.Template<FormRunnerForeignMutationsExpected>(
+    Co.GetState().then(current =>
+      !AsyncState.Operations.hasValue(current.formsConfig.sync) ?
+        Co.Wait(0)
+        : Co.UpdateState(_ => {
+          if (!AsyncState.Operations.hasValue(current.formsConfig.sync)) return id
+          if (current.formsConfig.sync.value.kind == "r")
+            return FormRunnerState.Updaters.form(
+              replaceWith(
+                Sum.Default.left(
+                  FormRunnerErrorsTemplate(current.formsConfig.sync.value)
+                )
+              )
+            )
+          const mappedForm = current.formsConfig.sync.value.value.mappings.get(current.formName)
+          if (mappedForm == undefined)
+            return FormRunnerState.Updaters.form(
+              replaceWith(
+                Sum.Default.left(
+                  FormRunnerErrorsTemplate(Sum.Default.right([`Cannot find form '${current.formName}'`]))
+                )
+              )
+            )
+          const instantiatedMappedForm = mappedForm()
+          return FormRunnerState.Updaters.form(
+            replaceWith(
+              Sum.Default.left({
+                form:instantiatedMappedForm.form,
+                formState:instantiatedMappedForm.initialState,
+                mapping:instantiatedMappedForm.mapping
+              })
+            )
+          )
+        })
+    ),
+    {
+      interval: 15,
+      runFilter: props =>
+        AsyncState.Operations.hasValue(props.context.formsConfig.sync) &&
+        props.context.form.kind == "r"
+    }
+  )
+}
+

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

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

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

@@ -0,0 +1,22 @@
+import { Mapping, simpleUpdater, Sum } from "../../../../main"
+import { FormsParserState } from "../parser/state"
+import { OnChange } from "../singleton/state"
+
+export type FormRunnerContext = {
+  value:any
+  extraContext:any
+  viewWrappers:any
+  formName:string
+} & FormsParserState
+export type FormRunnerState = {
+  form:Sum<{ form:any, formState:any, mapping:Mapping<any,any> }, "not initialized">
+}
+export type FormRunnerForeignMutationsExpected = { onChange:OnChange<any> }
+export const FormRunnerState = {
+  Default:():FormRunnerState => ({
+    form:Sum.Default.right("not initialized"),
+  }),
+  Updaters:{
+    ...simpleUpdater<FormRunnerState>()("form"),
+  }
+}

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

@@ -0,0 +1,47 @@
+import { List } from "immutable"
+import { BasicUpdater, FormRunnerContext, FormRunnerForeignMutationsExpected, FormRunnerLoader, FormRunnerState, Mapping, Sum, unit } from "../../../../main"
+import { Template } from "../../../template/state"
+import { FormParsingResult } from "../parser/state"
+
+export const FormRunnerErrorsTemplate = (parsedFormsConfig: FormParsingResult) => ({
+  form: Template.Default((props: any) =>
+    <>
+      {parsedFormsConfig.kind == "r" && JSON.stringify(parsedFormsConfig.value)}
+    </>),
+  formState: unit,
+  mapping: Mapping.Default.fromPaths(unit)
+})
+
+
+export const FormRunnerTemplate =
+  Template.Default<FormRunnerContext & FormRunnerState, FormRunnerState, FormRunnerForeignMutationsExpected>(props =>
+    props.context.form.kind == "r" ? <></> :
+      <>
+        <props.context.form.value.form
+          context={{
+            ...props.context.form.value.formState,
+            value: props.context.value,
+            formState: props.context.form.value.formState,
+            extraContext: {
+              ...props.context.extraContext,
+              rootValue: props.context.form.value.mapping.from(props.context.value),
+            }
+          }}
+          setState={(_:BasicUpdater<any>) => props.setState(
+            FormRunnerState.Updaters.form(
+              Sum.Updaters.left(
+                current => ({ ...current, formState: _(current.formState) })
+              )
+            )
+          )}
+          view={props.context.viewWrappers as any}
+          foreignMutations={{
+            onChange: (_:BasicUpdater<any>, _path:List<string>) => {
+              props.foreignMutations.onChange(_, _path)
+            }
+          }}
+        />
+
+      </>).any([
+        FormRunnerLoader()
+      ])

package/src/forms/domains/parser/coroutines/runner.ts

@@ -0,0 +1,34 @@
+import { AsyncState, FormsConfig, Sum, Synchronize, Unit } from "../../../../../main"
+import { CoTypedFactory } from "../../../../coroutines/builder"
+import { builtInsFromFieldViews, FormParsingResult, FormsParserContext, FormsParserState, parseForms } from "../state"
+
+export const LoadValidateAndParseFormsConfig = () => {
+  const Co = CoTypedFactory<FormsParserContext, FormsParserState>()
+
+ return Co.Template<Unit>(
+  Co.GetState().then(current => 
+  Synchronize<Unit, FormParsingResult>(async() => {
+    const formsConfig = await current.getFormsConfig()
+    const builtIns = builtInsFromFieldViews(current.fieldViews)
+    const validationResult = FormsConfig.Default.validateAndParseAPIResponse(builtIns)(formsConfig)
+    if (validationResult.kind == "r")
+      return Sum.Default.right(validationResult.value)
+    return parseForms(
+      current.containerFormView,
+      current.fieldViews,
+      current.infiniteStreamSources,
+      current.enumOptionsSources,
+      current.entityApis,
+      current.leafPredicates)(validationResult.value)
+  }, _ => "transient failure", 5, 50)
+    .embed(
+      _ => _.formsConfig,
+      FormsParserState.Updaters.formsConfig
+    )
+  ),
+  {
+    interval:15,
+    runFilter:props => !AsyncState.Operations.hasValue(props.context.formsConfig.sync)
+  }
+ )
+}