ballerina-core 1.0.39 → 1.0.41

package/package.json

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

package/src/async/domains/synchronized/coroutines/synchronize.ts

@@ -32,8 +32,8 @@ export const Synchronize = <value, syncResult, context = Unit>(
 };
 
 export const SynchronizeWithValueUpdater = <value, syncResult, context = Unit>(
-	p: BasicFun<value & context, Promise<[syncResult, BasicUpdater<value>]>>, errorProcessor: BasicFun<any, ErrorPermanenceStatus>,
-	maxAttempts: number, delayBetweenAttemptsInMs: number): 
+	p: BasicFun<value & context, Promise<[syncResult, BasicUpdater<value>]>>, errorProcessor: BasicFun<any, ErrorPermanenceStatus> = () => "transient failure",
+	maxAttempts: number = 2, delayBetweenAttemptsInMs: number = 250): 
 		Coroutine<Synchronized<value, syncResult> & context, Synchronized<value, syncResult>, ApiResultStatus> => {
 	const Co = CoTypedFactory<context, Synchronized<value, syncResult>>();
 	return Co.SetState(Synchronized.Updaters.sync(AsyncState.Updaters.toReloading())).then(() => 

package/src/forms/domains/parser/domains/built-ins/state.ts

@@ -128,7 +128,7 @@ export const defaultValue = <T>(types: Map<TypeName, TypeDefinition>, builtIns:
         if (custom != undefined) {
           let res = {} as any
           custom.fields.forEach((field, fieldName) => {
-            res[fieldName] = defaultValue(types, builtIns)(field.kind == "primitive" ? field.value : field.kind == "lookup" ? field.name : field.value)
+            res[fieldName] = defaultValue(types, builtIns, injectedPrimitives)(field.kind == "primitive" ? field.value : field.kind == "lookup" ? field.name : field.value)
           }
           )
           return res
@@ -233,10 +233,8 @@ export const fromAPIRawValue = <T>(t: Type, types: Map<TypeName, TypeDefinition>
   return obj
 }
 
-
 export const toAPIRawValue = <T>(t: Type, types: Map<TypeName, TypeDefinition>, builtIns: BuiltIns, converters: BuiltInApiConverters, isKeywordsReverted: boolean = false, injectedPrimitives?: InjectedPrimitives<T>) => (raw: any, formState: any) : any => {
   const obj = !isKeywordsReverted ? replaceKeywords(raw, "to api") : raw
-
   if (t.kind == "primitive") {
     return converters[t.value].toAPIRawValue([obj, formState.modifiedByUser] as never)
   } else if (t.kind == "application") { // application here means "generic type application"
@@ -291,9 +289,12 @@ export const toAPIRawValue = <T>(t: Type, types: Map<TypeName, TypeDefinition>,
       )
     }
 
-  } else { // t.kind == lookup: we are dealing with a record/object
+  } else { // t.kind == lookup: we are dealing with a record/object or extended type 
     let result: any = { ...obj }
     const tDef = types.get(t.name)!
+    if("extends" in tDef && tDef.extends.length == 1) {
+      return converters[(tDef.extends[0] as keyof BuiltInApiConverters)].toAPIRawValue([obj, formState.modifiedByUser] as never)
+    }
     tDef.fields.forEach((fieldType, fieldName) => {
       const revertedFieldName = revertKeyword(fieldName)
       const fieldValue = obj[revertedFieldName]
@@ -301,5 +302,5 @@ export const toAPIRawValue = <T>(t: Type, types: Map<TypeName, TypeDefinition>,
     })
     return result
   }
-  return defaultValue(types, builtIns)(t.value)
+  return defaultValue(types, builtIns, injectedPrimitives)(t.value)
 }

package/src/forms/domains/parser/domains/validator/state.ts

@@ -3,7 +3,7 @@ import { ApiConverters, BoolExpr, BuiltIns, FieldName, FormsConfigMerger, Inject
 
 export type FieldConfig = {
   renderer: string;
-  label: string;
+  label?: string;
   tooltip?: string;
   api: { stream?: string, enumOptions?: string };
   elementRenderer?: string;
@@ -104,11 +104,12 @@ export const FormsConfig = {
             if (injectedPrimitives?.injectedPrimitives.has(configFieldType as keyof T) && 
             (builtIns.primitives.has(configFieldType) || builtIns.generics.has(configFieldType))) {
               errors.push(`field ${fieldName} in type ${typeName}: injectedPrimitive cannot have same name as builtIn primitive`);
+            } else {
+              if (builtIns.primitives.has(configFieldType) || injectedPrimitives?.injectedPrimitives.has(configFieldType as keyof T))
+                typeDef.fields = typeDef.fields.set(fieldName, { kind: "primitive", value: configFieldType as any });
+              else
+                typeDef.fields = typeDef.fields.set(fieldName, { kind: "lookup", name: configFieldType as any })
             }
-            if (builtIns.primitives.has(configFieldType) || injectedPrimitives?.injectedPrimitives.has(configFieldType as keyof T))
-              typeDef.fields = typeDef.fields.set(fieldName, { kind: "primitive", value: configFieldType as any });
-            else
-              typeDef.fields = typeDef.fields.set(fieldName, { kind: "lookup", name: configFieldType as any });
           } else if (typeof configFieldType == "object") {
             if ("fun" in configFieldType && "args" in configFieldType &&
               typeof configFieldType["fun"] == "string" &&
@@ -477,7 +478,7 @@ export const FormsConfig = {
           formDef.fields = formDef.fields.set(
             fieldName, {
             renderer: fieldConfig.renderer,
-            label: fieldConfig.label ?? revertKeyword(fieldName),
+            label: fieldConfig.label,
             tooltip: fieldConfig.tooltip,
             elementTooltip: fieldConfig.elementTooltip,
             elementRenderer: fieldConfig.elementRenderer,

package/src/forms/domains/parser/state.tsx

@@ -24,7 +24,7 @@ const parseOptions = (leafPredicates: any, options: any) => {
 };
 
 export const FieldView = //<Context, FieldViews extends DefaultFieldViews, EnumFieldConfigs extends {}, EnumSources extends {}>() => <ViewType extends keyof FieldViews, ViewName extends keyof FieldViews[ViewType]>
-  <T,>(fieldConfig:FieldConfig, fieldViews: any, viewType: any, viewName: any, fieldName: string, label: string, tooltip: string | undefined, enumFieldConfigs: EnumOptionsSources, enumSources: any, leafPredicates: any, injectedPrimitives?: InjectedPrimitives<T>): any =>
+  <T,>(fieldConfig:FieldConfig, fieldViews: any, viewType: any, viewName: any, label: string | undefined, tooltip: string | undefined, enumFieldConfigs: EnumOptionsSources, enumSources: any, leafPredicates: any, injectedPrimitives?: InjectedPrimitives<T>): any =>
   {
     if (viewType == "maybeBoolean")
       return MaybeBooleanForm<any & FormLabel, Unit>()
@@ -208,8 +208,8 @@ export const ParseForm = <T,>(
           ).withView(((fieldViews as any)[viewType] as any)[viewName]() as any)
             .mapContext<any>(_ => ({ ..._, label, tooltip }))
         } else { // the list argument is a primitive
-          const elementForm = FieldView(fieldConfig, fieldViews, fieldNameToElementViewCategory(formFieldElementRenderers)(fieldName) as any, elementRendererName, fieldName, elementLabel ?? label, elementTooltip, EnumOptionsSources, fieldsOptionsConfig, leafPredicates, injectedPrimitives)
-          const initialFormState = FieldFormState(fieldConfig, fieldViews, fieldNameToElementViewCategory(formFieldElementRenderers)(fieldName) as any, elementRendererName, fieldName, InfiniteStreamSources, fieldsInfiniteStreamsConfig, injectedPrimitives);
+          const elementForm = FieldView(fieldConfig, fieldViews, fieldNameToElementViewCategory(formFieldElementRenderers)(fieldName) as any, elementRendererName, elementLabel, elementTooltip, EnumOptionsSources, fieldsOptionsConfig, leafPredicates, injectedPrimitives)
+          const initialFormState = FieldFormState(fieldConfig, fieldViews, fieldNameToElementViewCategory(formFieldElementRenderers)(fieldName) as any, elementRendererName, InfiniteStreamSources, fieldsInfiniteStreamsConfig, injectedPrimitives);
           formConfig[fieldName] = ListForm<any, any, any & FormLabel, Unit>(
             { Default: () => initialFormState },
             { Default: () => initialElementValue },
@@ -239,7 +239,7 @@ export const ParseForm = <T,>(
           const initialValueValue = defaultValue(valueType)
           const getFormAndInitialState = (elementRenderers:any, rendererName:any, fieldConfig:FieldConfig) => {
             const formDef = otherForms.get(rendererName)
-            const elementLabel = elementRenderers[fieldName].label ?? label
+            const elementLabel = elementRenderers[fieldName].label
             const elementTooltip = elementRenderers[fieldName].tooltip
             if (formDef != undefined) {
               return [
@@ -248,7 +248,7 @@ export const ParseForm = <T,>(
               ]
             } else {
               const categoryName = fieldNameToElementViewCategory(elementRenderers)(fieldName) as any
-              const form = FieldView(fieldConfig, fieldViews, categoryName, rendererName, fieldName, elementLabel, elementTooltip, EnumOptionsSources, fieldsOptionsConfig, leafPredicates, injectedPrimitives)
+              const form = FieldView(fieldConfig, fieldViews, categoryName, rendererName, elementLabel, elementTooltip, EnumOptionsSources, fieldsOptionsConfig, leafPredicates, injectedPrimitives)
               const initialFormState = FieldFormState(fieldConfig, fieldViews, categoryName, rendererName, fieldName, InfiniteStreamSources, fieldsInfiniteStreamsConfig, injectedPrimitives);
               return [
                 form,
@@ -272,7 +272,7 @@ export const ParseForm = <T,>(
           ).withView(((fieldViews as any)[viewType] as any)[viewName]() as any)
             .mapContext<any>(_ => ({ ..._, label, tooltip }))
         } else {
-          formConfig[fieldName] = FieldView(fieldConfig, fieldViews, viewType, viewName, fieldName, label, tooltip, EnumOptionsSources, fieldsOptionsConfig, leafPredicates, injectedPrimitives);
+          formConfig[fieldName] = FieldView(fieldConfig, fieldViews, viewType, viewName, label, tooltip, EnumOptionsSources, fieldsOptionsConfig, leafPredicates, injectedPrimitives);
         }
       }
     }
@@ -409,6 +409,15 @@ export const parseForms =
               if (formsConfig.forms.has(field.elementRenderer))
                 traverse(formsConfig.forms.get(field.elementRenderer)!)
             }
+            if (fieldType?.kind == "application" && fieldType?.value == "Map" && fieldType?.args.length == 2 && field.mapRenderer != undefined) {
+              const mapRenderer = field.mapRenderer
+              if (mapRenderer && formsConfig.forms.has(mapRenderer.keyRenderer.renderer)) {
+                traverse(formsConfig.forms.get(mapRenderer.keyRenderer.renderer)!)
+              }
+              if (mapRenderer && formsConfig.forms.has(mapRenderer.valueRenderer.renderer)) {
+                traverse(formsConfig.forms.get(mapRenderer.valueRenderer.renderer)!)
+              }
+            }
           } catch (error) {
             errors.push(`unhandled error: ${JSON.stringify(error)} -> ${formDef.name}`)
           }
@@ -507,6 +516,7 @@ export const parseForms =
           create: ([value, formState]: [any, any]) => {
             // alert(`type = ${JSON.stringify(parsedForm.formDef.type)}`)
             // alert(`value = ${JSON.stringify(value)}`)
+            console.log("value", JSON.stringify(value))
             const raw = toAPIRawValue({ kind: "lookup", name: parsedForm.formDef.type }, formsConfig.types, builtIns, apiConverters, false, injectedPrimitives)(value, formState)
             // alert(`raw = ${JSON.stringify(raw.interests)}`)
             return entityApis.create(launcher.api)(raw)
@@ -598,13 +608,13 @@ export const replaceKeywords = (obj: any, kind: "from api" | "to api"): any => {
     );
   } else if (typeof obj === "object" && obj !== null) {
     if(OrderedMap.isOrderedMap(obj)) {
-      return obj.map((_, key) =>
-        replacementFn(key as string)
+      return obj.mapEntries(([key, _]) =>
+        [replacementFn(key as string), _]
       )
     }
     if(Map.isMap(obj)) {
-      return obj.map((_, key) =>
-        replacementFn(key as string)
+      return obj.mapEntries(([key, _]) =>
+        [replacementFn(key as string), _]
       )
     }
     const copy = { ...obj };

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

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

package/src/value/domains/flagged-value/state.ts

@@ -0,0 +1,27 @@
+import { BasicUpdater, Updater } from "../../../fun/domains/updater/state";
+import { Value } from "../../state";
+
+export type FlaggedValue<v> = Value<v> & { flag: boolean };
+
+export const FlaggedValue = {
+  Default: <v>(v: v, flag: boolean = false): FlaggedValue<v> => ({
+    ...Value.Default(v),
+    flag,
+  }),
+  Updaters: {
+    Core: {
+      value: <v>(_: BasicUpdater<v>): Updater<FlaggedValue<v>> =>
+        Updater<FlaggedValue<v>>((current) => ({
+          ...current,
+          value: _(current.value),
+        })),
+    },
+    Template: {
+      flag: <v>(flag: boolean): Updater<FlaggedValue<v>> =>
+        Updater<FlaggedValue<v>>((current) => ({
+          ...current,
+          flag,
+        })),
+    },
+  },
+};