ballerina-core 1.0.72 → 1.0.77

package/main.ts

@@ -117,6 +117,12 @@ export * from "./src/forms/domains/launcher/state"
 export * from "./src/forms/domains/launcher/template"
 export * from "./src/forms/domains/parser/domains/injectables/state"
 export * from "./src/forms/domains/collection/domains/unionCase/state"
+export * from "./src/forms/domains/parser/domains/predicates/state"
+export * from "./src/forms/domains/integrated-forms/domains/launcher/domains/integrated-form/state"
+export * from "./src/forms/domains/integrated-forms/domains/launcher/domains/integrated-form/template"
+export * from "./src/forms/domains/integrated-forms/domains/parser/state"
+export * from "./src/forms/domains/integrated-forms/domains/launcher/state"
+export * from "./src/forms/domains/integrated-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.72",
+  "version": "1.0.77",
   "main": "main.ts",
   "dependencies": {
     "immutable": "^5.0.0-beta.5",

package/src/collections/domains/immutable/domains/list/state.ts

@@ -13,9 +13,26 @@ export const ListRepo = {
     push<V>(v:V): Updater<List<V>> {
       return Updater((_) => _.push(v));
     },
+    insert<V>(elementIndex:number, v:V): Updater<List<V>> {
+      return Updater((_) => _.insert(elementIndex, v));
+    },
     filter<V>(predicate: BasicFun<V, boolean>): Updater<List<V>> {
       return Updater((_) => _.filter(predicate));
     },
+    move<V>(elementIndex:number, to:number): Updater<List<V>> {
+      return Updater((_) => {
+        const element = _.get(elementIndex)
+        if(element == undefined) return _
+        return _.remove(elementIndex).insert(to, element)
+      });
+    },
+    duplicate<V>(elementIndex:number): Updater<List<V>> {
+      return Updater((_) => {
+        const element = _.get(elementIndex)
+        if(element == undefined) return _
+        return _.insert(elementIndex + 1, element)
+      });
+    },
   },
   Operations: {
   },

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

@@ -2,7 +2,7 @@ import { List } from "immutable";
 import { BasicFun, BasicFun2, Fun } from "../../../fun/state";
 import { Value } from "../../../value/state";
 import { Errors } from "../errors/state"
-import { unit, Unit, Updater, Option } from "../../../../main";
+import { unit, Unit, Updater, Option, Sum } from "../../../../main";
 
 export type ValueOrErrors<v, e> = (
   | (Value<v> & { kind: "value" })
@@ -122,25 +122,23 @@ export const ValueOrErrors = {
           ValueOrErrors.Operations.Map<a, ValueOrErrors<b, e>, e>(k)(_)
         )
       ),
+    Catch: <v, e>(_: ValueOrErrors<v, e>): ValueOrErrors<Sum<v, List<e>>, e> =>
+      _.kind == "errors" ?
+        ValueOrErrors.Default.return(Sum.Default.right(_.errors)) : ValueOrErrors.Default.return(Sum.Default.left(_.value)),
     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> =>
-      _.reduce(
-        (reduction, value) =>
-          ValueOrErrors.Operations.Fold<v, e, ValueOrErrors<List<v>, e>>(
-            (v: v) =>
-              reduction.kind == "errors"
-                ? reduction
-                : reduction.Map((_) => _.concat(v)),
-            (es: List<e>) =>
-              reduction.kind == "errors"
-                ? reduction.MapErrors((_) => _.concat(es))
-                : ValueOrErrors.Default.throw(es)
-          )(value),
-        ValueOrErrors.Default.return(List<v>())
-      ),
+      _.size == 0 ? 
+        ValueOrErrors.Default.return(List())
+      : ValueOrErrors.Operations.Catch(_.first()!).Then(res_p => 
+        res_p.kind == "l" ? 
+          ValueOrErrors.Operations.All(_.slice(1).toList()).Then(values => 
+            ValueOrErrors.Default.return(List<v>().push(res_p.value).concat(values))
+          )
+        : ValueOrErrors.Default.throw(res_p.value)
+      )
   },
 };

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

@@ -0,0 +1,61 @@
+import { List } from "immutable"
+import { id, replaceWith, Sum, ValueOrErrors } from "../../../../../../../main"
+import { AsyncState } from "../../../../../../async/state"
+import { CoTypedFactory } from "../../../../../../coroutines/builder"
+import {  IntegratedFormRunnerForeignMutationsExpected, IntegratedFormRunnerState, IntegratedFormRunnerContext, IntegratedForm } from "../state"
+import { IntegratedFormRunnerErrorsTemplate } from "../template"
+
+export const IntegratedFormRunnerLoader = <E,>() => {
+  const Co = CoTypedFactory<IntegratedFormRunnerContext<E>, IntegratedFormRunnerState<E>>()
+
+  return Co.Template<IntegratedFormRunnerForeignMutationsExpected>(
+    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 == "errors")
+            return IntegratedFormRunnerState<E>().Updaters.form(
+              replaceWith(
+                Sum.Default.left(
+                    IntegratedFormRunnerErrorsTemplate(current.formsConfig.sync.value)
+                )
+              )
+            )
+            
+          const formRef = current.formRef
+          
+        const form = current.formsConfig.sync.value.value.get(formRef.formName)
+        if (form == undefined)
+            return IntegratedFormRunnerState<E>().Updaters.form(
+              replaceWith(
+                  Sum.Default.left(
+                  IntegratedFormRunnerErrorsTemplate(ValueOrErrors.Default.throw(List([`Cannot find form '${formRef.formName}'`])))
+                  )   
+              )
+            )
+            const instantiatedForm = form()
+        return IntegratedFormRunnerState<E>().Updaters.form(
+          replaceWith<Sum<IntegratedForm<E>, "not initialized">>(
+              Sum.Default.left<IntegratedForm<E>, "not initialized">({
+                form: instantiatedForm.form,
+                formFieldStates: instantiatedForm.initialState.formFieldStates,
+                commonFormState: instantiatedForm.initialState.commonFormState,
+                customFormState: instantiatedForm.initialState.customFormState,
+                fromApiParser: instantiatedForm.fromApiParser as (value: any) => E,
+                toApiParser: instantiatedForm.toApiParser,
+                parseGlobalConfiguration: instantiatedForm.parseGlobalConfiguration
+              })
+          )
+        )
+        })
+    ),
+    {
+      interval: 15,
+      runFilter: props =>
+        AsyncState.Operations.hasValue(props.context.formsConfig.sync) &&
+        props.context.form.kind == "r"
+    }
+  )
+}
+

package/src/forms/domains/integrated-forms/domains/launcher/domains/integrated-form/coroutines/runner.ts

@@ -0,0 +1,80 @@
+import { List } from "immutable";
+import { Synchronize, Unit, replaceWith, Sum, ValueOrErrors, Debounce, id } from "../../../../../../../../../main";
+import { ApiResultStatus } from "../../../../../../../../apiResultStatus/state";
+import { AsyncState } from "../../../../../../../../async/state";
+import { CoTypedFactory } from "../../../../../../../../coroutines/builder";
+import { Debounced } from "../../../../../../../../debounced/state";
+import { PredicateValue, evaluatePredicates, FormFieldPredicateEvaluation } from "../../../../../../parser/domains/predicates/state";
+import { IntegratedFormContext, IntegratedFormForeignMutationsExpected, IntegratedFormWritableState, IntegratedFormState } from "../state";
+
+
+export const integratedFormRunner = <E, FS>() => {
+  const Co = CoTypedFactory<
+    IntegratedFormContext<E, FS> & IntegratedFormForeignMutationsExpected<E, FS> & { onRawEntityChange: (updatedRawEntity: any, path: List<string>) => void },
+    IntegratedFormWritableState<E, FS>
+  >();
+
+  const calculateInitialVisibilities = Co.GetState().then((current) => { 
+    const parsedRootPredicate = PredicateValue.Operations.parse(current.initialRawEntity.value, current.formType, current.types)
+    
+    if(parsedRootPredicate.kind == "errors") {
+      console.error('error parsing bindings', parsedRootPredicate)
+      return Co.Do(() => {})
+    }
+    if(typeof parsedRootPredicate.value != "object" || !("kind" in parsedRootPredicate.value) || parsedRootPredicate.value.kind != "record") {
+      return Co.Do(() => {})
+    }
+    return Co.SetState(IntegratedFormState<E, FS>().Updaters.Core.customFormState.children.predicateEvaluations(
+      replaceWith(Debounced.Default(evaluatePredicates({
+        global: current.globalConfiguration.value,
+        types: current.types,
+        visibilityPredicateExpressions: current.visibilityPredicateExpressions,
+        disabledPredicatedExpressions: current.disabledPredicatedExpressions
+      }, parsedRootPredicate.value)))).then(IntegratedFormState<E, FS>().Updaters.Core.customFormState.children.isInitialized(replaceWith(true)))
+    )
+  })
+
+  const PredicatesCo = CoTypedFactory<IntegratedFormWritableState<E, FS> & IntegratedFormContext<E, FS>, ValueOrErrors<{
+    visiblityPredicateEvaluations: FormFieldPredicateEvaluation;
+    disabledPredicateEvaluations: FormFieldPredicateEvaluation;
+  }, string>>();
+
+  const calculateVisibilities = Co.Repeat(
+    Debounce<ValueOrErrors<{visiblityPredicateEvaluations: FormFieldPredicateEvaluation; disabledPredicateEvaluations: FormFieldPredicateEvaluation;}, string>, IntegratedFormContext<E, FS> & IntegratedFormWritableState<E, FS>>(
+    PredicatesCo.GetState().then((current) => { 
+      if(current.entity.kind == "r" || current.globalConfiguration.kind == "r") {
+        return PredicatesCo.Return<ApiResultStatus>("permanent failure")
+      }
+      const parsedEntity = current.toApiParser(current.entity.value, current, false)
+      if(parsedEntity.kind == "errors") {
+        console.error('error parsing entity', parsedEntity)
+        return PredicatesCo.Return<ApiResultStatus>("permanent failure")
+      }
+      const parseRootPredicate = PredicateValue.Operations.parse(parsedEntity.value, current.formType, current.types)
+      if(parseRootPredicate.kind == "errors") {
+        console.error('error parsing', parseRootPredicate)
+        return PredicatesCo.Return<ApiResultStatus>("permanent failure")
+      }
+      return PredicatesCo.SetState(replaceWith(evaluatePredicates({
+        global: current.globalConfiguration.value,
+        types: current.types,
+        visibilityPredicateExpressions: current.visibilityPredicateExpressions,
+        disabledPredicatedExpressions: current.disabledPredicatedExpressions
+    }, parseRootPredicate.value))).then(() => PredicatesCo.Return<ApiResultStatus>("success"))})
+  , 50)
+  .embed(
+    (_) => ({ ..._, ..._.customFormState.predicateEvaluations }),
+    IntegratedFormState<E, FS>().Updaters.Core.customFormState.children.predicateEvaluations)
+  )
+
+  return Co.Template<IntegratedFormForeignMutationsExpected<E, FS>>(calculateInitialVisibilities, {
+      interval: 15,
+      runFilter: (props) => !props.context.customFormState.isInitialized && props.context.globalConfiguration.kind != "r" && props.context.initialRawEntity.kind != "r"
+    }).any([
+    Co.Template<IntegratedFormForeignMutationsExpected<E, FS>>(calculateVisibilities, {
+      interval: 15,
+      runFilter: (props) =>
+        Debounced.Operations.shouldCoroutineRun(props.context.customFormState.predicateEvaluations)
+    }),
+  ]);
+};

package/src/forms/domains/integrated-forms/domains/launcher/domains/integrated-form/state.ts

@@ -0,0 +1,98 @@
+import {
+  ParsedType,
+  Template,
+  Value,
+  ValueOrErrors,
+  PredicateValue,
+  FieldPredicateExpressions,
+  CommonFormState,
+  FormFieldPredicateEvaluation,
+  simpleUpdater,
+  Debounced,
+  simpleUpdaterWithChildren,
+  Updater,
+  id,
+  ForeignMutationsInput,
+  Sum
+} from "../../../../../../../../main";
+import { List, Map } from "immutable";
+
+export type IntegratedFormContext<E, FS> = {
+  formType: ParsedType<E>;
+  types: Map<string, ParsedType<E>>;
+  globalConfiguration: Sum<PredicateValue, "not initialized">;
+  initialRawEntity: Sum<any, "not initialized">;
+  entity: Sum<E, "not initialized">;
+  onRawEntityChange: (updater: Updater<E>, path: List<string>) => void;
+  toApiParser: (
+    entity: E,
+    formstate: IntegratedFormState<E,FS>,
+    checkKeys: boolean
+  ) => ValueOrErrors<E, string>;
+  fromApiParser: (raw: any) => any;
+  parseGlobalConfiguration: (raw: any) => ValueOrErrors<PredicateValue, string>;
+  visibilityPredicateExpressions: FieldPredicateExpressions;
+  disabledPredicatedExpressions: FieldPredicateExpressions;
+  actualForm: Template<
+    Value<E> & { formFieldStates: FS } & {
+      commonFormState: CommonFormState;
+    } & { visibilities: FormFieldPredicateEvaluation | undefined } & {
+      disabledFields: FormFieldPredicateEvaluation | undefined;
+    },
+    { formFieldStates: FS } & { commonFormState: CommonFormState },
+    { onChange: (e: Updater<E>, path: List<string>) => void }
+  >;
+};
+
+export type IntegratedFormState<E,FS> = {
+  formFieldStates: FS,  
+  commonFormState: CommonFormState,
+  customFormState: {
+    isInitialized: boolean,
+    predicateEvaluations: Debounced<ValueOrErrors<{
+      visiblityPredicateEvaluations: FormFieldPredicateEvaluation;
+      disabledPredicateEvaluations: FormFieldPredicateEvaluation;
+    }, string>>,
+  }
+}
+
+export const IntegratedFormState = <E,FS>() => ({
+    Default:(formFieldStates:FS, commonFormState: CommonFormState) : IntegratedFormState<E,FS> => ({
+      formFieldStates,
+      commonFormState,
+      customFormState: {
+        isInitialized: false,
+        predicateEvaluations: Debounced.Default(ValueOrErrors.Default.return({
+        visiblityPredicateEvaluations: FormFieldPredicateEvaluation.Default.form(false, Map()),
+        disabledPredicateEvaluations: FormFieldPredicateEvaluation.Default.form(false, Map())
+        }))
+      }
+    }),
+    Updaters:{
+      Core:{
+        ...simpleUpdater<IntegratedFormState<E,FS>>()("formFieldStates"),
+        ...simpleUpdaterWithChildren<IntegratedFormState<E,FS>>()({
+            ...simpleUpdater<IntegratedFormState<E,FS>["customFormState"]>()("predicateEvaluations"),
+            ...simpleUpdater<IntegratedFormState<E,FS>["customFormState"]>()("isInitialized"),
+        })("customFormState"),
+        ...simpleUpdater<IntegratedFormState<E,FS>>()("commonFormState"),
+      },
+      Template:{
+        recalculatePredicates: () : Updater<IntegratedFormState<E,FS>> => 
+          IntegratedFormState<E,FS>().Updaters.Core.customFormState.children.predicateEvaluations(
+            Debounced.Updaters.Template.value(
+              id
+            )
+          )
+      }
+    },
+    ForeignMutations: (_: ForeignMutationsInput<IntegratedFormContext<E,FS>, IntegratedFormWritableState<E,FS>>) => ({
+  
+    })
+  })
+
+  export type IntegratedFormWritableState<E, FS> = IntegratedFormState<E,FS>
+  export type IntegratedFormForeignMutationsExposed<E,FS> = ReturnType<ReturnType<typeof IntegratedFormState<E,FS>>["ForeignMutations"]>
+  export type IntegratedFormForeignMutationsExpected<E, FS> = {
+
+  }

package/src/forms/domains/integrated-forms/domains/launcher/domains/integrated-form/template.tsx

@@ -0,0 +1,74 @@
+import { unit } from "../../../../../../../../main";
+import { Template } from "../../../../../../../template/state";
+import { IntegratedFormContext, IntegratedFormForeignMutationsExpected, IntegratedFormState, IntegratedFormWritableState } from "./state";
+import { integratedFormRunner } from "./coroutines/runner";
+export type IntegratedFormView<E, FS> =
+  Template<
+    IntegratedFormContext<E, FS> & IntegratedFormWritableState<E, FS>,
+    IntegratedFormWritableState<E, FS>,
+    IntegratedFormForeignMutationsExpected<E, FS>,
+    {
+      actualForm: JSX.Element | undefined
+    }>
+export type IntegratedFormTemplate<E, FS> =
+  Template<
+    IntegratedFormContext<E, FS> & IntegratedFormWritableState<E, FS>,
+    IntegratedFormWritableState<E, FS>,
+    IntegratedFormForeignMutationsExpected<E, FS>,
+    IntegratedFormView<E, FS>>
+export const IntegratedFormTemplate = <E, FS>(): IntegratedFormTemplate<E, FS> =>
+  Template.Default<
+    IntegratedFormContext<E, FS> & IntegratedFormWritableState<E, FS>,
+    IntegratedFormWritableState<E, FS>,
+    IntegratedFormForeignMutationsExpected<E, FS>,
+    IntegratedFormView<E, FS>>(props => {
+      if(props.context.entity.kind == "r" || props.context.globalConfiguration.kind == "r") {
+        return <>
+        </>
+      }
+      const visibilities = props.context.customFormState.predicateEvaluations.kind == "value" && 
+        props.context.customFormState.predicateEvaluations.value.visiblityPredicateEvaluations.kind == "form" ?
+        props.context.customFormState.predicateEvaluations.value.visiblityPredicateEvaluations : undefined;
+      const disabledFields = props.context.customFormState.predicateEvaluations.kind == "value" 
+        && props.context.customFormState.predicateEvaluations.value.disabledPredicateEvaluations.kind == "form" ?
+        props.context.customFormState.predicateEvaluations.value.disabledPredicateEvaluations : undefined;
+      return <>
+        {
+          props.view({
+            ...props, 
+            ...props.foreignMutations,
+            view: {
+              ...props.view,
+              actualForm:
+                  props.context.actualForm({
+                    context: {
+                      value: props.context.entity.value,
+                      formFieldStates: props.context.formFieldStates,
+                      commonFormState: props.context.commonFormState,
+                      visibilities,
+                      disabledFields
+                    },
+                    setState: _ => {
+                      props.setState(__ => ({
+                        ...__,
+                        formFieldStates: _(__).formFieldStates,
+                        commonFormState: _(__).commonFormState
+                      }))
+                    },
+                    foreignMutations: {
+                      onChange: (updater, path) => {
+                        if(props.context.entity.kind == "r") 
+                          return
+                        props.context.onRawEntityChange(updater, path)
+                        props.setState(IntegratedFormState<E, FS>().Updaters.Template.recalculatePredicates())
+                      }
+                    },
+                    view: unit
+                  })
+            }
+          })
+        }
+      </>
+    }).any([
+      integratedFormRunner<E, FS>()
+    ])

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

@@ -0,0 +1,38 @@
+import { List } from "immutable"
+import { PredicateValue, Sum, Unit, ValueOrErrors, simpleUpdater } from "../../../../../../main"
+import { BasicFun } from "../../../../../fun/state"
+import { IntegratedFormParsingResult, IntegratedFormsParserState } from "../parser/state"
+
+export type IntegratedFormRef = {
+    formName:string
+  } 
+
+export type IntegratedFormRunnerContext<E> = {
+    extraContext:any,
+    initialRawEntity: Sum<any, "not initialized">,
+    entity: Sum<E, "not initialized">,
+    globalConfiguration: Sum<PredicateValue, "not initialized">,
+    containerWrapper: any,
+    formRef:IntegratedFormRef,
+    showFormParsingErrors: BasicFun<IntegratedFormParsingResult, JSX.Element>
+} & IntegratedFormsParserState
+
+export type IntegratedForm<E> = { form:any, formFieldStates:any, commonFormState:any, customFormState:any, fromApiParser: (value: any) => E, toApiParser: (value: E, formState: any, checkKeys: boolean) => ValueOrErrors<any, string>, parseGlobalConfiguration: (raw: any) => ValueOrErrors<PredicateValue, string> }
+
+export type IntegratedFormRunnerState<E> = {
+    form: Sum<IntegratedForm<E>, "not initialized">,
+    shouldUpdate: boolean
+}
+export type IntegratedFormRunnerForeignMutationsExpected = {
+    onRawEntityChange: (updatedRawEntity: any, path: List<string>) => void
+}
+export const IntegratedFormRunnerState = <E,>() => ({
+    Default:(): IntegratedFormRunnerState<E> => ({
+        form: Sum.Default.right("not initialized"),
+        shouldUpdate: false
+    }),
+    Updaters:{
+        ...simpleUpdater<IntegratedFormRunnerState<E>>()("form"),
+        ...simpleUpdater<IntegratedFormRunnerState<E>>()("shouldUpdate"),
+    }
+})

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

@@ -0,0 +1,53 @@
+import { BasicUpdater, Sum, unit } from "../../../../../../main"
+import { Template } from "../../../../../template/state"
+
+import { IntegratedFormRunnerContext, IntegratedFormRunnerForeignMutationsExpected, IntegratedFormRunnerState } from "./state"
+import { IntegratedFormParsingResult } from "../parser/state"
+import { IntegratedFormRunnerLoader } from "./coroutines/runner"
+
+export const IntegratedFormRunnerErrorsTemplate = <E,>(parsedFormsConfig: IntegratedFormParsingResult) => ({
+  form: Template.Default<IntegratedFormRunnerContext<E> & IntegratedFormRunnerState<E>, IntegratedFormRunnerState<E>, IntegratedFormRunnerForeignMutationsExpected>(props =>
+    <>
+      {JSON.stringify(parsedFormsConfig)}
+      <br />
+      {JSON.stringify(props)}
+    </>),
+  formFieldStates: unit,
+  commonFormState: unit,
+  customFormState: unit,
+  fromApiParser: (value: any) => value,
+  toApiParser: (value: any, formState: any, checkKeys: boolean) => value,
+  parseGlobalConfiguration: (raw: any) => raw,
+})
+
+export const IntegratedFormRunnerTemplate = <E,>() => {
+  return Template.Default<IntegratedFormRunnerContext<E> & IntegratedFormRunnerState<E>, IntegratedFormRunnerState<E>, IntegratedFormRunnerForeignMutationsExpected>(props => {
+    if (props.context.form.kind == "r") return <></>
+    return <>
+        <props.context.form.value.form
+          context={{
+            initialRawEntity: props.context.initialRawEntity,
+            entity: props.context.entity,
+            globalConfiguration: props.context.globalConfiguration,
+            formFieldStates: props.context.form.value.formFieldStates,
+            commonFormState: props.context.form.value.commonFormState,
+            customFormState: props.context.form.value.customFormState,
+            containerWrapper: props.context.containerWrapper,
+            onRawEntityChange: props.foreignMutations.onRawEntityChange,
+            extraContext: {
+              ...props.context.extraContext,
+            },
+          }}
+          setState={(_: BasicUpdater<any>) => props.setState(
+            IntegratedFormRunnerState<E>().Updaters.form(Sum.Updaters.left(_))
+          )}
+          view={unit}
+          foreignMutations={{
+          }}
+        />
+
+      </>
+      }).any([
+        IntegratedFormRunnerLoader()
+    ])
+}

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

@@ -0,0 +1,38 @@
+import { AsyncState, builtInsFromFieldViews, injectablesFromFieldViews, Synchronize, Unit } from "../../../../../../../main"
+import { CoTypedFactory } from "../../../../../../coroutines/builder"
+import { IntegratedFormsConfig } from "../../validator/state"
+import { IntegratedFormParsingResult, IntegratedFormsParserContext, IntegratedFormsParserState, parseIntegratedFormsToLaunchers } from "../state"
+export const LoadValidateAndParseIntegratedFormsConfig = <T extends {[key in keyof T] : {type: any, state: any}}>() => {
+  const Co = CoTypedFactory<IntegratedFormsParserContext<T>, IntegratedFormsParserState>()
+
+ return Co.Template<Unit>(
+  Co.GetState().then(current => 
+  Synchronize<Unit, IntegratedFormParsingResult>(async() => {
+    const rawFormsConfig = await current.getFormsConfig();
+    const builtIns = builtInsFromFieldViews(current.fieldViews)
+    const injectedPrimitives = current.injectedPrimitives ? injectablesFromFieldViews(current.fieldViews, current.injectedPrimitives) : undefined
+    return IntegratedFormsConfig.Default.validateAndParseIntegratedFormConfig(builtIns, current.fieldTypeConverters, injectedPrimitives)(rawFormsConfig).Then(
+        validationResult =>
+            parseIntegratedFormsToLaunchers(
+                builtIns,
+                injectedPrimitives,
+                current.fieldTypeConverters,
+                current.containerFormView,
+                current.nestedContainerFormView,
+                current.fieldViews,
+                current.infiniteStreamSources,
+                current.enumOptionsSources,
+                )(validationResult) 
+    )
+  }, _ => "transient failure", 5, 50)
+    .embed(
+      _ => _.formsConfig,
+      IntegratedFormsParserState.Updaters.formsConfig
+    )
+  ),
+  {
+    interval:15,
+    runFilter:props => !AsyncState.Operations.hasValue(props.context.formsConfig.sync)
+  }
+ )
+}