ballerina-core 1.0.74 → 1.0.78

package/main.ts

@@ -118,6 +118,11 @@ 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.74",
+  "version": "1.0.78",
   "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/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)
+  }
+ )
+}

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

@@ -0,0 +1,138 @@
+import { Map } from "immutable"
+
+import { FormFieldPredicateEvaluation, simpleUpdater, unit, Unit, BasicFun, Synchronized, Template, Injectables, PredicateValue, fromAPIRawValue, toAPIRawValue, ValueOrErrors, Debounced } from "../../../../../../main"
+import { EnumOptionsSources, InfiniteStreamSources, ParseForms } from "../../../parser/state"
+import { BuiltIns } from "../../../../../../main";
+import { ApiConverters, InjectedPrimitives } from "../../../../../../main";
+import { ParsedIntegratedFormJSON } from "../validator/state";
+import { IntegratedFormContext, IntegratedFormForeignMutationsExpected, IntegratedFormState } from "../launcher/domains/integrated-form/state";
+import { IntegratedFormTemplate } from "../launcher/domains/integrated-form/template";
+import { LoadValidateAndParseIntegratedFormsConfig } from "./coroutines/runner";
+
+export const IntegratedFormsParserTemplate = <T extends {[key in keyof T] : {type: any, state: any}} = Unit>() => LoadValidateAndParseIntegratedFormsConfig<T>()
+
+export type ParsedIntegratedLaunchers = Map<string, <Entity, FormState, ExtraContext>() =>
+    {
+      form:
+      Template<IntegratedLauncherContext<Entity, FormState, ExtraContext> & IntegratedFormState<Entity, FormState>,
+        IntegratedFormState<Entity, FormState>, IntegratedFormForeignMutationsExpected<Entity, FormState>>,
+      initialState: IntegratedFormState<Entity, FormState>,
+      fromApiParser: (value: any) => Entity,
+      toApiParser: (value: any, formState: any, checkKeys: boolean) => any,
+      parseGlobalConfiguration: (raw: any) => ValueOrErrors<PredicateValue, string>
+    }>
+
+export type IntegratedLauncherContext<Entity, FormState, ExtraContext> =
+    Omit<
+        IntegratedFormContext<Entity, FormState> &
+        IntegratedFormState<Entity, FormState> & {
+        extraContext: ExtraContext,
+        containerFormView: any,
+        containerWrapper: any
+        }, "api" | "actualForm">
+
+export type IntegratedFormParsingResult = ValueOrErrors<ParsedIntegratedLaunchers, string>
+
+export const parseIntegratedFormsToLaunchers =
+<T extends { [key in keyof T]: { type: any; state: any; }; },>(
+    builtIns: BuiltIns,
+    injectedPrimitives: InjectedPrimitives<T> | undefined,
+    apiConverters: ApiConverters<T>,
+    containerFormView: any,
+    nestedContainerFormView: any,
+    fieldViews: any,
+    infiniteStreamSources: InfiniteStreamSources,
+    enumOptionsSources: EnumOptionsSources,
+    ) =>
+    (formsConfig: ParsedIntegratedFormJSON<T>):
+    IntegratedFormParsingResult => {
+
+    return ParseForms(
+        builtIns,
+        injectedPrimitives,
+        nestedContainerFormView,
+        fieldViews,
+        infiniteStreamSources,
+        enumOptionsSources,
+    )(formsConfig).Then(parsedForms => {
+        let parsedLaunchers: ParsedIntegratedLaunchers = Map()
+        formsConfig.launchers.forEach((launcher, launcherName) => {
+        const parsedForm = parsedForms.get(launcher.form)!
+        const form = parsedForm.form
+        const globalConfigurationType = formsConfig.types.get(launcher.globalConfigurationType)!
+        const initialState = parsedForm.initialFormState
+        const formType = parsedForm.formDef.type;
+        const visibilityPredicateExpressions = parsedForm.visibilityPredicateExpressions
+        const disabledPredicatedExpressions = parsedForm.disabledPredicatedExpressions
+        parsedLaunchers = parsedLaunchers.set(
+            launcherName,
+            <Entity, FormState, ExtraContext, Context extends IntegratedLauncherContext<Entity, FormState, ExtraContext>>() => ({
+            form: IntegratedFormTemplate<Entity, FormState>().mapContext((parentContext: Context) =>
+                ({
+                initialRawEntity: parentContext.initialRawEntity,
+                entity: parentContext.entity,
+                globalConfiguration: parentContext.globalConfiguration,
+                commonFormState: parentContext.commonFormState,
+                customFormState: parentContext.customFormState,
+                formFieldStates: parentContext.formFieldStates,
+                extraContext: parentContext.extraContext,
+                visibilityPredicateExpressions,
+                disabledPredicatedExpressions,
+                types: formsConfig.types,
+                formType: formType,
+                onRawEntityChange: parentContext.onRawEntityChange,
+                parseGlobalConfiguration: (raw: any) => PredicateValue.Operations.parse(raw, globalConfigurationType, formsConfig.types),
+                fromApiParser: (value: any) => fromAPIRawValue(formType, formsConfig.types, builtIns, apiConverters, injectedPrimitives)(value),
+                toApiParser: (value: any, formState: any, checkKeys: boolean) => toAPIRawValue(formType , formsConfig.types, builtIns, apiConverters, injectedPrimitives)(value, formState, checkKeys),
+                actualForm: form.withView(containerFormView).mapContext((_: any) => ({
+                    value: _.value,
+                    entity: _.entity,
+                    toApiParser: parentContext.toApiParser,
+                    fromApiParser: parentContext.fromApiParser,
+                    parseGlobalConfiguration: parentContext.parseGlobalConfiguration,
+                    formFieldStates: parentContext.formFieldStates,
+                    rootValue: _.value,
+                    extraContext: parentContext.extraContext,
+                    commonFormState: parentContext.commonFormState,
+                    predicateEvaluations: parentContext.customFormState.predicateEvaluations,
+                    visibilities: _.visibilities,
+                    disabledFields: _.disabledFields,
+                    }))
+                }) as any)
+                .withViewFromProps(props => props.context.containerWrapper)
+                .mapForeignMutationsFromProps(props => props.foreignMutations as any),
+            initialState: IntegratedFormState<Entity, FormState>().Default(initialState.formFieldStates, initialState.commonFormState),
+            fromApiParser: (value: any): Entity => fromAPIRawValue(formType, formsConfig.types, builtIns, apiConverters, injectedPrimitives)(value),
+            toApiParser: (value: any, formState: any, checkKeys: boolean) => toAPIRawValue(formType , formsConfig.types, builtIns, apiConverters, injectedPrimitives)(value, formState, checkKeys),
+            parseGlobalConfiguration: (raw: any) => PredicateValue.Operations.parse(raw, globalConfigurationType, formsConfig.types),
+            })
+        )
+        })
+        return ValueOrErrors.Default.return(parsedLaunchers)
+    })
+    
+    }
+
+export type IntegratedFormsParserContext<T extends {[key in keyof T] : {type: any, state: any}}> = {
+    containerFormView: any,
+    nestedContainerFormView: any,
+    fieldViews: any,
+    fieldTypeConverters: ApiConverters<T>,
+    infiniteStreamSources: InfiniteStreamSources,
+    enumOptionsSources: EnumOptionsSources,
+    injectedPrimitives?: Injectables<T>,
+    formsConfig: any,
+    getFormsConfig: BasicFun<void, Promise<any>>
+}
+    
+export type IntegratedFormsParserState = {
+    formsConfig: Synchronized<Unit, IntegratedFormParsingResult>
+}
+export const IntegratedFormsParserState = {
+Default: (): IntegratedFormsParserState => ({
+    formsConfig: Synchronized.Default(unit)
+}),
+Updaters: {
+    ...simpleUpdater<IntegratedFormsParserState>()("formsConfig")
+}
+}