ballerina-core 1.0.64 → 1.0.66

package/package.json

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

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

@@ -2,18 +2,18 @@ import { simpleUpdater } from "../../../../../../main";
 
 
 export type CollectionReference = {
-  id: string;
-  displayName: string;
+  Id: string;
+  DisplayValue: string;
   source?:"enum"|"stream"
 };
 export const CollectionReference = {
-  Default: Object.assign((id: string, displayName: string, source?:"enum"|"stream"): CollectionReference => ({
-    id, displayName, source
+  Default: Object.assign((Id: string, DisplayValue: string, source?:"enum"|"stream"): CollectionReference => ({
+    Id, DisplayValue, source
   }), {
     empty: (): CollectionReference => CollectionReference.Default("", "")
   }),
   Updaters: {
-    ...simpleUpdater<CollectionReference>()("id"),
-    ...simpleUpdater<CollectionReference>()("displayName"),
+    ...simpleUpdater<CollectionReference>()("Id"),
+    ...simpleUpdater<CollectionReference>()("DisplayValue"),
   }
 };

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

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

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

@@ -5,6 +5,20 @@ import { BasicFun } from "../../../../../fun/state";
 import { InjectedPrimitives, Maybe, ParsedType, TypeName } from "../../../../../../main";
 import { ValueOrErrors } from "../../../../../collections/domains/valueOrErrors/state";
 
+const sortObjectKeys = (obj: Record<string, any>) =>
+  Object.keys(obj)
+      .sort()
+      .reduce((sortedObj, key) => {
+      sortedObj[key] = obj[key]!;
+      return sortedObj;
+      }, {} as any);
+  
+const simpleMapKeyToIdentifer = (key: any): string  => {
+  if(typeof key == "object")
+    return JSON.stringify(sortObjectKeys(key));
+  return JSON.stringify(key);
+}
+
 export const PrimitiveTypes =
   [ 
     "guid", //resolves to string
@@ -31,17 +45,18 @@ export type ApiConverter<T> =  { fromAPIRawValue: BasicFun<any, T>, toAPIRawValu
 export type ApiConverters<T extends {[key in keyof T]: {type: any, state: any}}> = {[key in keyof T]: ApiConverter<T[key]["type"]> } & BuiltInApiConverters
 
 export type BuiltInApiConverters = {
-  "string": ApiConverter<string>
-  "number": ApiConverter<number>
-  "boolean": ApiConverter<boolean>
-  "maybeBoolean": ApiConverter<boolean | undefined>
-  "base64File": ApiConverter<string>
-  "secret": ApiConverter<string>
-  "Date": ApiConverter<Maybe<Date>>
-  "SingleSelection": ApiConverter<CollectionSelection<any>>
-  "MultiSelection": ApiConverter<OrderedMap<string, any>>
-  "List": ApiConverter<List<any>>,
-  "Map": ApiConverter<List<[any, any]>>
+  "string": ApiConverter<string>;
+  "number": ApiConverter<number>;
+  "boolean": ApiConverter<boolean>;
+  "maybeBoolean": ApiConverter<boolean | undefined>;
+  "base64File": ApiConverter<string>;
+  "secret": ApiConverter<string>;
+  "Date": ApiConverter<Maybe<Date>>;
+  "unionCase": ApiConverter<CollectionReference>;
+  "SingleSelection": ApiConverter<CollectionSelection<CollectionReference | { Value: CollectionReference }>>;
+  "MultiSelection": ApiConverter<OrderedMap<string, CollectionReference>>;
+  "List": ApiConverter<List<any>>;
+  "Map": ApiConverter<List<[any, any]>>;
 }
 
 export type PrimitiveBuiltIn = { renderers: Set<keyof BuiltIns["renderers"]>, defaultValue: any }
@@ -141,7 +156,8 @@ export const defaultValue = <T>(types: Map<TypeName, ParsedType<T>>, builtIns: B
   throw Error(`cannot find type ${JSON.stringify(t)} when resolving defaultValue`)
 }
 
-export const fromAPIRawValue = <T extends { [key in keyof T]: { type: any; state: any; } }>(t: ParsedType<T>, types: Map<TypeName, ParsedType<T>>, builtIns: BuiltIns, converters: ApiConverters<T>, injectedPrimitives?: InjectedPrimitives<T>) => (raw: any): any => {
+export const fromAPIRawValue = <T extends { [key in keyof T]: { type: any; state: any; } }>(t: ParsedType<T>, types: Map<TypeName, ParsedType<T>>, builtIns: BuiltIns, converters: ApiConverters<T>, injectedPrimitives?: InjectedPrimitives<T>) => (raw: any): any => {  
+  
   if (raw == undefined) {
     return defaultValue(types, builtIns, injectedPrimitives)(t)
   }
@@ -150,12 +166,15 @@ export const fromAPIRawValue = <T extends { [key in keyof T]: { type: any; state
     return converters[t.value].fromAPIRawValue(raw)
   }
   if(t.kind == "union") {
-    return CollectionReference.Default(raw, raw, "enum")
+    return fromAPIRawValue({kind: "unionCase", name: "", fields: {} as ParsedType<T>}, types, builtIns, converters, injectedPrimitives)(raw)
+  }
+  if(t.kind == "unionCase") {
+    return converters[t.kind].fromAPIRawValue(raw)
   }
   if (t.kind == "application") {
     if (t.value == "SingleSelection") {
-      return CollectionSelection().Updaters.left(
-        fromAPIRawValue(t.args[0], types, builtIns, converters, injectedPrimitives))(converters[t.value].fromAPIRawValue(raw))
+      return CollectionSelection().Updaters.left(fromAPIRawValue(t.args[0], types, builtIns, converters, injectedPrimitives))
+        (converters[t.value].fromAPIRawValue(raw))
     }
     if (t.value == "MultiSelection") {
       return converters["MultiSelection"].fromAPIRawValue(raw).map(fromAPIRawValue(t.args[0], types, builtIns, converters, injectedPrimitives))
@@ -196,8 +215,13 @@ export const fromAPIRawValue = <T extends { [key in keyof T]: { type: any; state
 export const toAPIRawValue = <T extends { [key in keyof T]: { type: any; state: any; }}>(t: ParsedType<T>, types: Map<TypeName, ParsedType<T>>, builtIns: BuiltIns, converters: ApiConverters<T>, injectedPrimitives?: InjectedPrimitives<T>) => (raw: any, formState: any) : ValueOrErrors<any, string> => {
   if (t.kind == "primitive")
     return ValueOrErrors.Operations.Return(converters[t.value as string | keyof T].toAPIRawValue([raw, formState.modifiedByUser]))
+
   if(t.kind == "union"){
-    return ValueOrErrors.Operations.Return(raw.id)
+    return toAPIRawValue({kind: "unionCase", name: "", fields: {} as ParsedType<T>}, types, builtIns, converters, injectedPrimitives)(raw, formState)
+  }
+
+  if(t.kind == "unionCase") {
+    return ValueOrErrors.Operations.Return(converters[t.kind].toAPIRawValue([raw, formState.modifiedByUser]))
   }
   if (t.kind == "application") {
     if (t.value == "SingleSelection") {
@@ -221,7 +245,7 @@ export const toAPIRawValue = <T extends { [key in keyof T]: { type: any; state:
         ))))
     }
     if (t.value == "Map") {
-      const [converterResult, toIdentiferAndDisplayName] = converters[t.value].toAPIRawValue([raw, formState.modifiedByUser])
+      const converterResult = List(converters[t.value].toAPIRawValue([raw, formState.modifiedByUser]))
       const parsedMap: List<ValueOrErrors<{key: ValueOrErrors<any, any>, value: ValueOrErrors<any, any>}, any>> = converterResult.map((keyValue: any, index: number) => {
         return toAPIRawValue(
             t.args[0],
@@ -243,12 +267,14 @@ export const toAPIRawValue = <T extends { [key in keyof T]: { type: any; state:
       )
       
       const nonUniqueKeyErrors = parsedMap.filter(_ => _.kind == "value").reduce((acc, _) => { 
-        const [id, displayName] = toIdentiferAndDisplayName(_.value.key)
-        acc.ids.contains(id) ? acc.errors = acc.errors.push(ValueOrErrors.Default.throw(List([`Keys in the map are not unique: ${displayName}`]))) : acc.ids = acc.ids.push(id)
+        const id = simpleMapKeyToIdentifer(_.value.key)
+        acc.ids.contains(id) ? acc.errors = acc.errors.push(ValueOrErrors.Default.throw(List([`Keys in the map are not unique`]))) : acc.ids = acc.ids.push(id)
         return acc
       }, {ids: List<string>(), errors: List<ValueOrErrors<any, string>>()}).errors
 
-      return ValueOrErrors.Operations.All(parsedMap.concat(nonUniqueKeyErrors))
+      return ValueOrErrors.Operations.All(parsedMap.concat(nonUniqueKeyErrors)).Then(parsedMap => 
+        ValueOrErrors.Default.return(parsedMap.toArray())
+      )
     }
   }
   

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

@@ -212,7 +212,7 @@ export const ParsedRenderer = {
       if (viewKind == "boolean")
         return BooleanForm<any & FormLabel, Unit>()
           .withView(formViews[viewKind][viewName]())
-          .mapContext<any & CommonFormState & Value<boolean>>(_ => ({ ..._, label, tooltip, details }))
+          .mapContext<any & CommonFormState & Value<boolean>>(_ => ({ ..._, label, tooltip, details })) 
       if (viewKind == "date")
         return DateForm<any & FormLabel, Unit>()
           .withView(formViews[viewKind][viewName]())
@@ -226,18 +226,18 @@ export const ParsedRenderer = {
           .withView(formViews[viewKind][viewName]())
           .mapContext<any & CommonFormState & Value<string>>(_ => ({ ..._, label, tooltip, details }))
       if (viewKind == "enumSingleSelection" && rendererConfig.kind == "enum")
-        return EnumForm<any & FormLabel & BaseEnumContext<Value<CollectionReference>>, Unit, Value<CollectionReference>>()
+        return EnumForm<any & FormLabel & BaseEnumContext<{ Value: CollectionReference }>, Unit, { Value: CollectionReference }>()
           .withView(formViews[viewKind][viewName]())
-          .mapContext<any & EnumFormState<any & BaseEnumContext<Value<CollectionReference>>, Value<CollectionReference>> & Value<CollectionSelection<Value<CollectionReference>>>>(_ => ({
+          .mapContext<any & EnumFormState<any & BaseEnumContext<{ Value: CollectionReference }>, { Value: CollectionReference }> & Value<CollectionSelection<{ Value: CollectionReference }>>>(_ => ({
             ..._, label, tooltip, details, getOptions: () => {
-              return ((enumOptionsSources as any)(rendererConfig.options)() as Promise<any>).then(options => Map(options.map((o: {value: CollectionReference}) => [o.value.id, o])))
+              return ((enumOptionsSources as any)(rendererConfig.options)() as Promise<any>).then(options => Map(options.map((o: CollectionReference) => [o.Id, {Value: o}])))
             }
           })) 
       if (viewKind == "enumMultiSelection" && rendererConfig.kind == "enum")
-        return EnumMultiselectForm<any & FormLabel & BaseEnumContext<Value<CollectionReference>>, Unit, Value<CollectionReference>>()
+        return EnumMultiselectForm<any & FormLabel & BaseEnumContext<{ Value: CollectionReference }>, Unit, { Value: CollectionReference }>()
           .withView(formViews[viewKind][viewName]() )
-          .mapContext<any & EnumFormState<any & BaseEnumContext<Value<CollectionReference>>, Value<CollectionReference>> & Value<OrderedMap<Guid, CollectionReference>>>(_ => ({
-            ..._, label, details, tooltip, getOptions: () => ((enumOptionsSources as any)(rendererConfig.options)() as Promise<any>).then(options => OrderedMap(options.map((o: {value: CollectionReference}) => [o.value.id, o])))
+          .mapContext<any & EnumFormState<any & BaseEnumContext<{ Value: CollectionReference }>, { Value: CollectionReference }> & Value<OrderedMap<Guid, CollectionReference>>>(_ => ({
+            ..._, label, details, tooltip, getOptions: () => ((enumOptionsSources as any)(rendererConfig.options)() as Promise<any>).then(options => OrderedMap(options.map((o: CollectionReference) => [o.Id, {Value: o}])))
           })) 
       if (viewKind == "streamSingleSelection")
         return SearchableInfiniteStreamForm<CollectionReference, any & FormLabel, Unit>()

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

@@ -181,10 +181,6 @@ export const FormsConfig = {
         Object.entries(form.fields).forEach(([fieldName, field]: [fieldName: string, field: any]) =>
           {  
             const fieldType = formType.fields.get(fieldName)!
-            if(fieldType.kind == "application" && fieldType.value == "List" ){
-              console.debug("parsing field", fieldName, field)
-              console.debug('fieldType', formType.fields.get(fieldName)!);
-            }
 
             const bwcompatiblefield = fieldType.kind  == "application" && fieldType.value == "List" && typeof field.elementRenderer == "string" ? {
               renderer: field.renderer,
@@ -200,10 +196,6 @@ export const FormsConfig = {
               }
             }: field
 
-            if(fieldType.kind == "application" && fieldType.value == "List" ){
-              console.debug('bwcompatiblefield', bwcompatiblefield);
-
-            }
             return parsedForm.fields = parsedForm.fields.set(fieldName, ParsedRenderer.Operations.ParseRenderer(fieldType, bwcompatiblefield, parsedTypes))  
           }       
         )

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

@@ -121,7 +121,7 @@ export type EntityApis = {
 export type EnumName = string
 
 
-export type EnumOptionsSources = BasicFun<EnumName, BasicFun<Unit, Promise<Array<{value: CollectionReference}>>>>
+export type EnumOptionsSources = BasicFun<EnumName, BasicFun<Unit, Promise<Array<CollectionReference>>>>
 export const parseForms =
   <LeafPredicates, T extends { [key in keyof T]: { type: any; state: any; }; },>(
     builtIns: BuiltIns,
@@ -243,8 +243,7 @@ export const parseForms =
         const initialState = parsedForm.initialFormState
         const api = {
           get: (id: string) => entityApis.get(launcher.api)(id).then((raw: any) => {
-            const x =fromAPIRawValue(parsedForm.formDef.type , formsConfig.types, builtIns, apiConverters, injectedPrimitives)(raw)
-            return x
+            return fromAPIRawValue(parsedForm.formDef.type , formsConfig.types, builtIns, apiConverters, injectedPrimitives)(raw)
           }),
           update: (id: any, parsed: any) => {
             return parsed.kind =="errors" ? Promise.reject(parsed.errors) : entityApis.update(launcher.api)(id, parsed.value)  

package/src/forms/domains/primitives/domains/enum/state.ts

@@ -8,17 +8,17 @@ import { FormLabel } from "../../../singleton/domains/form-label/state";
 import { OnChange, CommonFormState } from "../../../singleton/state";
 
 
-export type BaseEnumContext<Element extends Value<CollectionReference>> = { getOptions:() => Promise<OrderedMap<Guid, Element>> }
-export type EnumFormState<Context, Element extends Value<CollectionReference>> = 
+export type BaseEnumContext<Element extends { Value: CollectionReference }> = { getOptions:() => Promise<OrderedMap<Guid, Element>> }
+export type EnumFormState<Context, Element extends { Value: CollectionReference }> = 
     { commonFormState: CommonFormState,
       customFormState: { options: Synchronized<Unit, OrderedMap<Guid, Element>>; }; };
-export const EnumFormState = <Context extends BaseEnumContext<Value<Element>>, Element extends CollectionReference>() => ({
-  Default: (): EnumFormState<Context, Value<Element>> => ({ 
+export const EnumFormState = <Context extends BaseEnumContext<{ Value: Element }>, Element extends CollectionReference>() => ({
+  Default: (): EnumFormState<Context, { Value: Element }> => ({ 
     commonFormState: CommonFormState.Default(),
     customFormState: { options: Synchronized.Default(unit) }
   }),
 });
-export type EnumView<Context extends FormLabel & BaseEnumContext<Element>, Element extends Value<CollectionReference>, ForeignMutationsExpected> = View<
+export type EnumView<Context extends FormLabel & BaseEnumContext<Element>, Element extends { Value: CollectionReference }, ForeignMutationsExpected> = View<
   Context & Value<CollectionSelection<Element>> & EnumFormState<Context, Element> & 
   { activeOptions: "loading" | Array<Element>; } & { disabled:boolean }, EnumFormState<Context, Element>, 
   ForeignMutationsExpected & { 

package/src/forms/domains/primitives/domains/enum/template.tsx

@@ -9,7 +9,7 @@ import { FieldValidation, FieldValidationWithPath, FormValidatorSynchronized, On
 import { BaseEnumContext, EnumFormState, EnumView } from "./state";
 
 
-export const EnumForm = <Context extends FormLabel & BaseEnumContext<Element>, ForeignMutationsExpected, Element extends Value<CollectionReference>>(
+export const EnumForm = <Context extends FormLabel & BaseEnumContext<Element>, ForeignMutationsExpected, Element extends { Value: CollectionReference }>(
   validation?: BasicFun<CollectionSelection<Element>, Promise<FieldValidation>>
 ) => {
   const Co = CoTypedFactory<Context & Value<CollectionSelection<Element>> & { disabled:boolean }, EnumFormState<Context, Element>>()

package/src/forms/domains/primitives/domains/enum-multiselect/state.ts

@@ -8,7 +8,7 @@ import { OnChange } from "../../../singleton/state";
 import { BaseEnumContext, EnumFormState } from "../enum/state";
 
 
-export type EnumMultiselectView<Context extends FormLabel & BaseEnumContext<Element>, Element extends Value<CollectionReference>, ForeignMutationsExpected> = View<
+export type EnumMultiselectView<Context extends FormLabel & BaseEnumContext<Element>, Element extends { Value: CollectionReference }, ForeignMutationsExpected> = View<
   Context & Value<OrderedMap<Guid, Element>> & EnumFormState<Context, Element> & {
     selectedIds: Array<Guid>;
     activeOptions: "loading" | Array<Element>;

package/src/forms/domains/primitives/domains/enum-multiselect/template.tsx

@@ -9,7 +9,7 @@ import { BaseEnumContext, EnumFormState } from "../enum/state";
 import { EnumMultiselectView } from "./state";
 
 
-export const EnumMultiselectForm = <Context extends FormLabel & BaseEnumContext<Element>, ForeignMutationsExpected, Element extends Value<CollectionReference>>(
+export const EnumMultiselectForm = <Context extends FormLabel & BaseEnumContext<Element>, ForeignMutationsExpected, Element extends { Value: CollectionReference }>(
   validation?: BasicFun<OrderedMap<Guid, Element>, Promise<FieldValidation>>
 ) => {
   const Co = CoTypedFactory<Context & Value<OrderedMap<Guid, Element>> & EnumFormState<Context, Element> & { disabled:boolean }, EnumFormState<Context, Element>>()
@@ -17,7 +17,7 @@ export const EnumMultiselectForm = <Context extends FormLabel & BaseEnumContext<
     <props.view {...props}
       context={{
         ...props.context,
-        selectedIds: props.context.value.map(_ => _.value.id).valueSeq().toArray(),
+        selectedIds: props.context.value.map(_ => _.Value.Id).valueSeq().toArray(),
         activeOptions: !AsyncState.Operations.hasValue(props.context.customFormState.options.sync) ? "loading"
         : props.context.customFormState.options.sync.value.valueSeq().toArray()
       }}
@@ -30,7 +30,7 @@ export const EnumMultiselectForm = <Context extends FormLabel & BaseEnumContext<
             .flatMap(_ => { 
               const selectedItem = options.get(_);
               if (selectedItem != undefined) {
-                const item: [string, Element] = [selectedItem.value.id, selectedItem];
+                const item: [string, Element] = [selectedItem.Value.Id, selectedItem];
                 return [item];
               }
               return [];

package/src/forms/domains/primitives/domains/searchable-infinite-stream-multiselect/template.tsx

@@ -93,9 +93,9 @@ export const InfiniteMultiselectDropdownForm = <Element extends CollectionRefere
           ),
         toggleSelection: element =>
           props.foreignMutations.onChange(
-            props.context.value.has(element.id) ?
-              OrderedMapRepo.Updaters.remove(element.id) :
-              OrderedMapRepo.Updaters.set(element.id, element),
+            props.context.value.has(element.Id) ?
+              OrderedMapRepo.Updaters.remove(element.Id) :
+              OrderedMapRepo.Updaters.set(element.Id, element),
             List()),
       }}
     />

package/src/infinite-data-stream/coroutines/builder.ts

@@ -1,7 +1,7 @@
 import { CoTypedFactory } from "../../coroutines/builder";
 import { InfiniteStreamReadonlyState, InfiniteStreamWritableState } from "../state";
 
-export const StreamCo = <Element extends { id: string }>() =>
+export const StreamCo = <Element extends { Id: string }>() =>
   CoTypedFactory<
     InfiniteStreamReadonlyState,
     InfiniteStreamWritableState<Element>

package/src/infinite-data-stream/coroutines/infiniteLoader.ts

@@ -3,7 +3,7 @@ import { replaceWith } from "../../fun/domains/updater/domains/replaceWith/state
 import { InfiniteStreamState, StreamPosition } from "../state";
 import { StreamCo } from "./builder";
 
-export const InfiniteStreamLoader = <Element extends { id: string }>() => {
+export const InfiniteStreamLoader = <Element extends { Id: string }>() => {
   const Co = StreamCo<Element>();
   const updaters = InfiniteStreamState<Element>().Updaters;
   // const operations = InfiniteStreamState<Element>().Operations;

package/src/infinite-data-stream/coroutines/runner.ts

@@ -3,7 +3,7 @@ import { StreamCo } from "./builder";
 import { Loader } from "./infiniteLoader";
 
 export const StreamDataLoader =
-  <Element extends { id: string }, foreignMutations>() => {
+  <Element extends { Id: string }, foreignMutations>() => {
     const operations = InfiniteStreamState<Element>().Operations;
     const LoaderTemplate = StreamCo<Element>().Template<foreignMutations>(Loader<Element>(), { 
       runFilter:props => operations.shouldCoroutineRun(props.context) 

package/src/infinite-data-stream/state.ts

@@ -8,7 +8,7 @@ import { BasicFun } from "../fun/state";
 
 export type StreamingStatus = "reload" | "loadMore" | false;
 
-type Identifiable = { id: string };
+type Identifiable = { Id: string };
 
 export type StreamPosition = {
   chunkSize: number;
@@ -68,12 +68,12 @@ export const StreamPosition = {
 
 export type Chunk<Element extends Identifiable> = {
   hasMoreValues: boolean;
-  data: OrderedMap<Element["id"], Element>;
+  data: OrderedMap<Element["Id"], Element>;
 };
 export const Chunk = <Element extends Identifiable>() => ({
   Default:(
     hasMoreValues: boolean,
-    data: OrderedMap<Element["id"], Element>,
+    data: OrderedMap<Element["Id"], Element>,
   ) : Chunk<Element> => ({
     hasMoreValues, data
   })
@@ -171,5 +171,5 @@ export const InfiniteStreamState = <Element extends Identifiable>() => ({
 });
 
 export type InfiniteStreamReadonlyState = Unit;
-export type InfiniteStreamWritableState<Element extends { id: string }> =
+export type InfiniteStreamWritableState<Element extends { Id: string }> =
   InfiniteStreamState<Element>;

package/src/infinite-data-stream/template.tsx

@@ -4,7 +4,7 @@ import { StreamDataLoader } from "./coroutines/runner";
 import { InfiniteStreamReadonlyState, InfiniteStreamWritableState } from "./state";
 
 export const InfiniteStreamTemplate =
-  <Element extends { id: string }>() => Template.Default<
+  <Element extends { Id: string }>() => Template.Default<
     InfiniteStreamReadonlyState,
     InfiniteStreamWritableState<Element>,
     Unit