ballerina-core 1.0.0

package/src/debounced/coroutines/debounce.ts

@@ -0,0 +1,118 @@
+import { ApiResultStatus } from "../../apiResultStatus/state";
+import { CoTypedFactory } from "../../coroutines/builder";
+import { Coroutine } from "../../coroutines/state";
+import { Unit } from "../../fun/domains/unit/state";
+import { replaceWith } from "../../fun/domains/updater/domains/replaceWith/state";
+import { Debounced, DebouncedStatus, DirtyStatus } from "../state";
+
+
+export const Debounce = <value, context = Unit>(
+  k: Coroutine<value & context, value, ApiResultStatus>,
+  debounceDurationInMs: number,
+  waitBeforeRetryOnTransientFailure: number = debounceDurationInMs * 2
+) => {
+  const Co = CoTypedFactory<context, Debounced<value>>();
+  const updaters = Debounced.Updaters;
+  return Co.Seq([
+    Co.SetState(
+      updaters.Core.status(replaceWith<DebouncedStatus>("waiting for dirty"))
+    ),
+    Co.While(
+      ([current]) =>
+        current.dirty != "dirty" ||
+        Date.now() - current.lastUpdated <= debounceDurationInMs,
+      Co.Wait(debounceDurationInMs / 5)
+    ),
+    Co.SetState(
+      updaters.Core.dirty(replaceWith<DirtyStatus>("dirty but being processed"))
+    ),
+    Co.SetState(
+      updaters.Core.status(
+        replaceWith<DebouncedStatus>("just detected dirty, starting processing")
+      )
+    ),
+    Co.Any([
+      // shortcircuit the validation if it takes longer than the whole cycle in the presence of an underwater update of the field
+      Co.Seq([
+        Co.While(
+          ([current]) =>
+            current.dirty != "dirty" ||
+            Date.now() - current.lastUpdated <= debounceDurationInMs,
+          Co.Wait(debounceDurationInMs / 5)
+        ),
+        Co.SetState(
+          updaters.Core.status(
+            replaceWith<DebouncedStatus>("processing shortcircuited")
+          )
+        ),
+        Co.Wait(debounceDurationInMs / 2),
+      ]),
+      k
+        .embed((_: Debounced<value & context>) => _, updaters.Core.value)
+        .then((apiResult) => {
+          return Co.Seq([
+            Co.SetState(
+              updaters.Core.status(
+                replaceWith<DebouncedStatus>("processing finished")
+              )
+            ),
+            // Co.Wait(250)
+          ]).then(() => {
+            return Co.GetState().then((current) => {
+              // alert(apiResult)
+              if (apiResult == "success" || apiResult == "permanent failure") {
+                // maybe a new change has already reset dirty, in that case we need to start all over again
+                if (current.dirty == "dirty but being processed") {
+                  return Co.Seq([
+                    Co.SetState(
+                      updaters.Core.status(
+                        replaceWith<DebouncedStatus>(
+                          "state was still dirty but being processed, resetting to not dirty"
+                        )
+                      )
+                    ),
+                    // use UpdateState to make sure that we look up the state at the last possible moment to account for delays
+                    Co.UpdateState((state) =>
+                      state.dirty == "dirty but being processed"
+                        ? updaters.Core.dirty(
+                            replaceWith<DirtyStatus>("not dirty")
+                          )
+                        : updaters.Core.dirty(replaceWith<DirtyStatus>("dirty"))
+                    ),
+                  ]);
+                } else {
+                  return Co.Seq([
+                    Co.SetState(
+                      updaters.Core.status(
+                        replaceWith<DebouncedStatus>(
+                          "state was changed underwater back to dirty, leaving the dirty flag alone"
+                        )
+                      )
+                    ),
+                    Co.SetState(
+                      updaters.Core.dirty(replaceWith<DirtyStatus>("dirty"))
+                    ),
+                    // Co.Wait(250)
+                  ]);
+                }
+              } else {
+                return Co.Seq([
+                  Co.SetState(
+                    updaters.Core.status(
+                      replaceWith<DebouncedStatus>(
+                        "inner call failed with transient failure"
+                      )
+                    )
+                  ),
+                  Co.SetState(
+                    updaters.Core.dirty(replaceWith<DirtyStatus>("dirty"))
+                  ),
+                  Co.Wait(waitBeforeRetryOnTransientFailure),
+                ]);
+              }
+            });
+          });
+        }),
+    ]),
+  ]);
+};

package/src/debounced/state.ts

@@ -0,0 +1,61 @@
+import { replaceWith } from "../fun/domains/updater/domains/replaceWith/state";
+import { BasicUpdater, Updater } from "../fun/domains/updater/state";
+
+export type DirtyStatus = "dirty" | "not dirty" | "dirty but being processed"
+export type DebouncedStatus = "waiting for dirty" | "just detected dirty, starting processing" 
+	| "processing finished" | "state was still dirty but being processed, resetting to not dirty"
+	| "processing shortcircuited"
+	| "state was changed underwater back to dirty, leaving the dirty flag alone"
+	| "inner call failed with transient failure"
+export type Debounced<Value> = Value & { lastUpdated: number; dirty: DirtyStatus; status:DebouncedStatus };
+export const Debounced = {
+	Default: <v>(initialValue: v): Debounced<v> => ({
+		...initialValue,
+		lastUpdated: 0,
+		dirty: "not dirty",
+		status: "waiting for dirty"
+	}),
+	Updaters: {
+		Core:{
+			status: <v>(_: BasicUpdater<DebouncedStatus>): Updater<Debounced<v>> => Updater<Debounced<v>>(current => ({
+				...current,
+				status: _(current.status),
+			})),
+			dirty: <v>(_: BasicUpdater<DirtyStatus>): Updater<Debounced<v>> => Updater<Debounced<v>>(current => ({
+				...current,
+				dirty: _(current.dirty),
+			})),
+			lastUpdated: <v>(_: BasicUpdater<number>): Updater<Debounced<v>> => Updater<Debounced<v>>(current => ({
+				...current,
+				lastUpdated: _(current.lastUpdated),
+			})),
+			valueWithoutDebouncing: <v>(_: BasicUpdater<v>): Updater<Debounced<v>> => Updater<Debounced<v>>(current => ({
+				...current,
+				...(_(current)),
+			})),
+			value: <v>(_: BasicUpdater<v>): Updater<Debounced<v>> => Updater<Debounced<v>>(current => ({
+				...(_(current)),
+				dirty: current.dirty,
+				lastUpdated: current.lastUpdated,
+				status: current.status
+			})),
+		},
+		Template:{
+			value: <v>(_: BasicUpdater<v>): Updater<Debounced<v>> => 
+				// Debounced.Updaters.Core.value(_).then(
+				// 	Debounced.Updaters.Core.dirty(replaceWith<DirtyStatus>("dirty"))
+				// ).then(
+				// 	Debounced.Updaters.Core.lastUpdated(replaceWith(Date.now()))
+				// )
+				Updater<Debounced<v>>(current => ({
+					...(_(current)),
+					dirty: "dirty",
+					lastUpdated: Date.now(),
+					status: current.status
+				}))
+		}
+	},
+	Operations:{
+		shouldCoroutineRun:<v>(_:Debounced<v>) => _.dirty != "not dirty"
+	}
+};

package/src/diagnostics/domains/message-box/state.ts

@@ -0,0 +1,4 @@
+export const messageBox = <a>(message:string, value:() => a) : a => {
+  alert(message)
+  return value()
+}

package/src/foreignMutations/state.ts

@@ -0,0 +1,4 @@
+import { BasicUpdater } from "../fun/domains/updater/state";
+import { BasicFun } from "../fun/state";
+
+export type ForeignMutationsInput<context, state> = { context:context & state, setState:BasicFun<BasicUpdater<state>, void> }

package/src/forms/domains/attachments/views/attachments-view.tsx

@@ -0,0 +1,22 @@
+import { OrderedMap } from "immutable";
+import { v4 } from "uuid";
+import { Guid, SimpleCallback } from "../../../../../main";
+
+
+
+export const AttachmentsList = (props: { attachments: OrderedMap<Guid, File>; add: SimpleCallback<[Guid, File]>; remove: SimpleCallback<Guid>; }) => <>
+  <ul>
+    {props.attachments.map((file, fileId) => <>
+      <button onClick={() => props.remove(fileId)}>
+        {file.name} 🗑️
+      </button>
+    </>
+    ).valueSeq()}
+  </ul>
+  <input
+    type="file"
+    onChange={e => {
+      if (e.currentTarget.files != null)
+        props.add([v4(), e.currentTarget.files[0]]);
+    }} />
+</>;

package/src/forms/domains/collection/domains/reference/state.ts

@@ -0,0 +1,18 @@
+import { simpleUpdater } from "../../../../../../main";
+
+
+export type CollectionReference = {
+  id: string;
+  displayName: string;
+};
+export const CollectionReference = {
+  Default: Object.assign((id: string, displayName: string): CollectionReference => ({
+    id, displayName
+  }), {
+    empty: (): CollectionReference => CollectionReference.Default("", "")
+  }),
+  Updaters: {
+    ...simpleUpdater<CollectionReference>()("id"),
+    ...simpleUpdater<CollectionReference>()("displayName"),
+  }
+};

package/src/forms/domains/collection/domains/selection/state.ts

@@ -0,0 +1,5 @@
+import { Sum } from "../../../../../../main";
+import { CollectionReference } from "../reference/state"
+
+export type CollectionSelection<Element extends CollectionReference> = Sum<Element, "no selection">;
+export const CollectionSelection = <Element extends CollectionReference>() => Sum<Element, "no selection">();

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

@@ -0,0 +1,60 @@
+import { ApiErrors, AsyncState, Debounce, Debounced, CreateFormForeignMutationsExpected, CreateFormState, Synchronize, Synchronized, Unit, SimpleCallback, unit, replaceWith } from "../../../../../../../main"
+import { CoTypedFactory } from "../../../../../../coroutines/builder"
+import { CreateFormContext, CreateFormWritableState } from "../state"
+
+export const createFormRunner = <E, FS>() => {
+  const Co = CoTypedFactory<CreateFormContext<E, FS> & { onSubmitted:SimpleCallback<E> }, CreateFormWritableState<E, FS>>()
+
+  const init =
+    Co.GetState().then(current =>
+      Synchronize<Unit, Synchronized<E, ApiErrors>>(() => current.api.default().then(e =>
+        Synchronized.Default<E, ApiErrors>(e)
+      ), _ => "transient failure", 5, 50)
+        .embed(_ => _.entity,
+          _ => CreateFormState<E, FS>().Updaters.Core.entity(Debounced.Updaters.Core.value(_)))
+    )
+
+  const synchronize =
+    Co.Repeat(
+      Co.Seq([
+      Co.GetState().then(current =>
+        Debounce<Synchronized<Unit, Synchronized<E, ApiErrors>>, CreateFormContext<E, FS>>(
+          Synchronize<E, ApiErrors>(e => current.api.create(e), _ => "transient failure", 5, 50)
+            .embed(
+              _ => AsyncState.Operations.hasValue(_.sync) ? _.sync.value : undefined,
+              _ => Synchronized.Updaters.sync<Unit, Synchronized<E, ApiErrors>>(AsyncState.Operations.map(_))
+            ),
+          15
+        ).embed(
+          _ => ({ ..._, ..._.entity }),
+          _ => CreateFormState<E, FS>().Updaters.Core.entity(_)
+        )
+      ),
+      Co.GetState().then(current =>
+        AsyncState.Operations.hasValue(current.entity.sync) && AsyncState.Operations.hasValue(current.entity.sync.value.sync) && current.notifySubmitAfterSync ?
+          Co.Seq([
+            Co.Do(() => {
+              if (AsyncState.Operations.hasValue(current.entity.sync) && AsyncState.Operations.hasValue(current.entity.sync.value.sync))
+                current.onSubmitted(current.entity.sync.value)
+            }),
+            Co.SetState(CreateFormState<E,FS>().Updaters.Core.notifySubmitAfterSync(replaceWith(false)))
+          ])
+        : Co.Return(unit)
+      )
+    ])
+    )
+
+  return Co.Template<CreateFormForeignMutationsExpected<E, FS>>(
+    init, {
+    interval: 15,
+    runFilter: props => !AsyncState.Operations.hasValue(props.context.entity.sync)
+  }
+  ).any([
+    Co.Template<CreateFormForeignMutationsExpected<E, FS>>(
+      synchronize, {
+      interval: 15,
+      runFilter: props => Debounced.Operations.shouldCoroutineRun(props.context.entity) || props.context.notifySubmitAfterSync
+    }
+    )
+  ])
+}

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

@@ -0,0 +1,71 @@
+import { ApiErrors, AsyncState, BasicUpdater, Debounced, ForeignMutationsInput, id, replaceWith, SimpleCallback, simpleUpdater, Synchronized, Template, unit, Unit, Updater, Value } from "../../../../../../main"
+import { BasicFun } from "../../../../../fun/state"
+
+export type CreateFormContext<E,FS> = {
+  entityId:string,
+  api:{
+    default:() => Promise<E>,
+    create:BasicFun<E, Promise<ApiErrors>>
+  },
+  actualForm:Template<Value<E> & FS, FS, { onChange:SimpleCallback<BasicUpdater<E>> }>
+}
+
+export type CreateFormState<E,FS> = {
+  // first sync is GET (returns E), second is UPDATE (accepts E)
+  entity:Debounced<Synchronized<Unit, Synchronized<E, ApiErrors>>>
+  formState:FS,
+  notifySubmitAfterSync:boolean
+}
+
+export const CreateFormState = <E,FS>() => ({
+  Default:(initialFormState:FS) : CreateFormState<E,FS> => ({
+    entity:Debounced.Default(
+      Synchronized.Default(unit)
+    ),
+    formState:initialFormState,
+    notifySubmitAfterSync:false
+  }),
+  Updaters:{
+    Core:{      
+      ...simpleUpdater<CreateFormState<E,FS>>()("notifySubmitAfterSync"),
+      ...simpleUpdater<CreateFormState<E,FS>>()("entity"),
+      ...simpleUpdater<CreateFormState<E,FS>>()("formState"),
+    },
+    Template:{
+      entity:(_:BasicUpdater<E>) : Updater<CreateFormState<E,FS>> => 
+        CreateFormState<E,FS>().Updaters.Core.entity(
+          Debounced.Updaters.Core.value(
+            Synchronized.Updaters.sync(
+              AsyncState.Operations.map(
+                Synchronized.Updaters.value(
+                  _
+                )
+              )
+            )
+          )
+        ),
+        submit:() : Updater<CreateFormState<E,FS>> => 
+          CreateFormState<E,FS>().Updaters.Core.entity(
+            Debounced.Updaters.Template.value(
+              Synchronized.Updaters.sync(
+                AsyncState.Operations.map(
+                  Synchronized.Updaters.value(
+                    id
+                  )
+                )
+              )
+            )
+          ).then(
+            CreateFormState<E,FS>().Updaters.Core.notifySubmitAfterSync(replaceWith(true))
+          )
+  
+    }
+  },
+  ForeignMutations: (_: ForeignMutationsInput<CreateFormContext<E,FS>, CreateFormWritableState<E,FS>>) => ({
+
+  })
+})
+
+export type CreateFormWritableState<E,FS> = CreateFormState<E,FS>
+export type CreateFormForeignMutationsExposed<E,FS> = ReturnType<ReturnType<typeof CreateFormState<E,FS>>["ForeignMutations"]>
+export type CreateFormForeignMutationsExpected<E,FS> = { onSubmitted:SimpleCallback<E> }

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

@@ -0,0 +1,66 @@
+import { AsyncState, createFormRunner, replaceWith, SimpleCallback, unit } from "../../../../../../main";
+import { Template, View } from "../../../../../template/state";
+import { CreateFormContext, CreateFormForeignMutationsExpected, CreateFormState, CreateFormWritableState } from "./state";
+
+export type CreateFormView<E, FS> =
+  Template<
+    CreateFormContext<E, FS> & CreateFormWritableState<E, FS>,
+    CreateFormWritableState<E, FS>,
+    CreateFormForeignMutationsExpected<E, FS> & { onSubmit: SimpleCallback<void> },
+    {
+      actualForm: JSX.Element | undefined
+    }>
+export type CreateFormTemplate<E, FS> =
+  Template<
+    CreateFormContext<E, FS> & CreateFormWritableState<E, FS>,
+    CreateFormWritableState<E, FS>,
+    CreateFormForeignMutationsExpected<E, FS>,
+    CreateFormView<E, FS>>
+export const CreateFormTemplate = <E, FS>(): CreateFormTemplate<E, FS> =>
+  Template.Default<
+    CreateFormContext<E, FS> & CreateFormWritableState<E, FS>,
+    CreateFormWritableState<E, FS>,
+    CreateFormForeignMutationsExpected<E, FS>,
+    CreateFormView<E, FS>>(props =>
+      <>
+        {
+
+          props.view({
+            ...props, 
+            foreignMutations: {
+              ...props.foreignMutations, onSubmit: () => {
+                props.setState(CreateFormState<E, FS>().Updaters.Template.submit())
+              }
+            },
+            view: {
+              ...props.view,
+              actualForm:
+                !AsyncState.Operations.hasValue(props.context.entity.sync) ? undefined :
+                  props.context.actualForm({
+                    context: {
+                      value: props.context.entity.sync.value,
+                      ...props.context.formState,
+                    },
+                    setState: _ => {
+                      props.setState(
+                        CreateFormState<E, FS>().Updaters.Core.formState(_)
+                      )
+                    },
+                    foreignMutations: {
+                      onChange: (e) => {
+                        props.setState(CreateFormState<E, FS>().Updaters.Template.entity(e))
+                      }
+                    },
+                    view: unit
+                  })
+
+            }
+          })
+        }
+      </>
+    ).any([
+      createFormRunner<E, FS>().mapContextFromProps(props => ({
+        ...props.context,
+        onSubmitted:props.foreignMutations.onSubmitted
+      }))
+    ])

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

@@ -0,0 +1,47 @@
+import { ApiErrors, AsyncState, Debounce, Debounced, EditFormForeignMutationsExpected, EditFormState, Synchronize, Synchronized, Unit } from "../../../../../../../main"
+import { CoTypedFactory } from "../../../../../../coroutines/builder"
+import { EditFormContext, EditFormWritableState } from "../state"
+
+export const editFormRunner = <E, FS>() => {
+  const Co = CoTypedFactory<EditFormContext<E, FS>, EditFormWritableState<E, FS>>()
+
+  const init =
+    Co.GetState().then(current =>
+      Synchronize<Unit, Synchronized<E, ApiErrors>>(() => current.api.get().then(e =>
+        Synchronized.Default<E, ApiErrors>(e)
+      ), _ => "transient failure", 5, 50)
+        .embed(_ => _.entity,
+          _ => EditFormState<E, FS>().Updaters.Core.entity(Debounced.Updaters.Core.value(_)))
+    )
+
+  const synchronize =
+    Co.Repeat(
+      Co.GetState().then(current =>
+        Debounce<Synchronized<Unit, Synchronized<E, ApiErrors>>, EditFormContext<E, FS>>(
+          Synchronize<E, ApiErrors>(e => current.api.update(e), _ => "transient failure", 5, 50)
+            .embed(
+              _ => AsyncState.Operations.hasValue(_.sync) ? _.sync.value : undefined,
+              _ => Synchronized.Updaters.sync<Unit, Synchronized<E, ApiErrors>>(AsyncState.Operations.map(_))
+            ),
+          15
+        ).embed(
+          _ => ({ ..._, ..._.entity }),
+          _ => EditFormState<E, FS>().Updaters.Core.entity(_)
+        )
+      )
+    )
+
+  return Co.Template<EditFormForeignMutationsExpected<E, FS>>(
+    init, {
+    interval: 15,
+    runFilter: props => !AsyncState.Operations.hasValue(props.context.entity.sync)
+  }
+  ).any([
+    Co.Template<EditFormForeignMutationsExpected<E, FS>>(
+      synchronize, {
+      interval: 15,
+      runFilter: props => Debounced.Operations.shouldCoroutineRun(props.context.entity)
+    }
+    )
+  ])
+}

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

@@ -0,0 +1,55 @@
+import { AsyncState, BasicUpdater, Debounced, ForeignMutationsInput, SimpleCallback, simpleUpdater, Synchronized, Template, unit, Unit, Updater, Value } from "../../../../../../main"
+import { BasicFun } from "../../../../../fun/state"
+
+export type ApiErrors = Array<string>
+
+export type EditFormContext<E,FS> = {
+  entityId:string,
+  api:{
+    get:() => Promise<E>,
+    update:BasicFun<E, Promise<ApiErrors>>
+  },
+  actualForm:Template<Value<E> & FS, FS, { onChange:SimpleCallback<BasicUpdater<E>> }>
+}
+
+export type EditFormState<E,FS> = {
+  // first sync is GET (returns E), second is UPDATE (accepts E)
+  entity:Debounced<Synchronized<Unit, Synchronized<E, ApiErrors>>>
+  formState:FS,
+}
+
+export const EditFormState = <E,FS>() => ({
+  Default:(initialFormState:FS) : EditFormState<E,FS> => ({
+    entity:Debounced.Default(
+      Synchronized.Default(unit)
+    ),
+    formState:initialFormState,
+  }),
+  Updaters:{
+    Core:{
+      ...simpleUpdater<EditFormState<E,FS>>()("entity"),
+      ...simpleUpdater<EditFormState<E,FS>>()("formState"),
+    },
+    Template:{
+      entity:(_:BasicUpdater<E>) : Updater<EditFormState<E,FS>> => 
+        EditFormState<E,FS>().Updaters.Core.entity(
+          Debounced.Updaters.Template.value(
+            Synchronized.Updaters.sync(
+              AsyncState.Operations.map(
+                Synchronized.Updaters.value(
+                  _
+                )
+              )
+            )
+          )
+        )
+    }
+  },
+  ForeignMutations: (_: ForeignMutationsInput<EditFormContext<E,FS>, EditFormWritableState<E,FS>>) => ({
+
+  })
+})
+
+export type EditFormWritableState<E,FS> = EditFormState<E,FS>
+export type EditFormForeignMutationsExposed<E,FS> = ReturnType<ReturnType<typeof EditFormState<E,FS>>["ForeignMutations"]>
+export type EditFormForeignMutationsExpected<E,FS> = Unit

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

@@ -0,0 +1,39 @@
+import { AsyncState, editFormRunner, replaceWith, unit } from "../../../../../../main";
+import { Template } from "../../../../../template/state";
+import { EditFormContext, EditFormForeignMutationsExpected, EditFormState, EditFormWritableState } from "./state";
+
+export type EditFormTemplate<E, FS> =
+  Template<
+    EditFormContext<E, FS> & EditFormWritableState<E, FS>,
+    EditFormWritableState<E, FS>,
+    EditFormForeignMutationsExpected<E, FS>>
+export const EditFormTemplate = <E, FS>() : EditFormTemplate<E,FS> =>
+  Template.Default<
+    EditFormContext<E, FS> & EditFormWritableState<E, FS>,
+    EditFormWritableState<E, FS>,
+    EditFormForeignMutationsExpected<E, FS>>(props =>
+      <>
+        {
+          !AsyncState.Operations.hasValue(props.context.entity.sync) ? undefined :
+            props.context.actualForm({
+              context: {
+                value: props.context.entity.sync.value,
+                ...props.context.formState,
+              },
+              setState: _ => {
+                props.setState(
+                  EditFormState<E, FS>().Updaters.Core.formState(_)
+                )
+              },
+              foreignMutations: {
+                onChange: (e) => {
+                  props.setState(EditFormState<E, FS>().Updaters.Template.entity(e))
+                }
+              },
+              view: unit
+            })
+        }
+      </>
+    ).any([
+      editFormRunner<E, FS>()
+    ])