create-foldkit-app 0.29.0 → 0.29.1

package/dist/templates/examples/job-application/src/step/education/education.ts

@@ -54,20 +54,17 @@ export const GenerateEntryId = Command.define('GenerateEntryId', {
 
 // UPDATE
 
-type UpdateReturn = readonly [Model, ReadonlyArray<Command.Command<Message>>]
-
 const foldEntryOutMessage: (
   entryId: string,
 ) => (outMessage: Entry.OutMessage) => Update.Step<Model, Message> = entryId =>
   M.type<Entry.OutMessage>().pipe(
     M.withReturnType<Update.Step<Model, Message>>(),
     M.tagsExhaustive({
-      Removed: () => model => [
-        evo(model, {
+      Removed: () => model => ({
+        model: evo(model, {
           entries: Array.filter(entry => entry.id !== entryId),
         }),
-        [],
-      ],
+      }),
     }),
   )
 
@@ -85,24 +82,22 @@ const foldEntry = (entryId: string) =>
   })
 
 export const update = (model: Model, message: Message) =>
-  Message.match<UpdateReturn>(message, {
-    ClickedAddEntry: () => [model, [GenerateEntryId()]],
+  Message.match<Update.Return<Model, Message>>(message, {
+    ClickedAddEntry: () => ({ model, commands: [GenerateEntryId()] }),
 
-    SucceededGenerateEntryId: ({ entryId }) => [
-      evo(model, {
+    SucceededGenerateEntryId: ({ entryId }) => ({
+      model: evo(model, {
         entries: Array.append(Entry.init(entryId)),
       }),
-      [],
-    ],
+    }),
 
-    FailedGenerateEntryId: () => [model, []],
+    FailedGenerateEntryId: () => ({ model }),
 
-    RemovedEntry: ({ entryId }) => [
-      evo(model, {
+    RemovedEntry: ({ entryId }) => ({
+      model: evo(model, {
         entries: Array.filter(entry => entry.id !== entryId),
       }),
-      [],
-    ],
+    }),
 
     GotEntryMessage: ({ entryId, message }) =>
       foldEntry(entryId)(model, message),

package/dist/templates/examples/job-application/src/step/education/entry.ts

@@ -1,5 +1,5 @@
 import { Match as M, Option, Schema as S } from 'effect'
-import { Command, Update } from 'foldkit'
+import { Update } from 'foldkit'
 import {
   Field,
   NotValidated,
@@ -87,21 +87,14 @@ export const init = (entryId: string): Model => ({
 
 // UPDATE
 
-type UpdateReturn = readonly [
-  Model,
-  ReadonlyArray<Command.Command<Message>>,
-  Option.Option<OutMessage>,
-]
-
 const foldGraduationYearListboxOutMessage = M.type<Listbox.OutMessage>().pipe(
   M.withReturnType<Update.Step<Model, Message>>(),
   M.tagsExhaustive({
     Selected:
       ({ value }) =>
-      model => [
-        evo(model, { maybeGraduationYear: () => Option.some(value) }),
-        [],
-      ],
+      model => ({
+        model: evo(model, { maybeGraduationYear: () => Option.some(value) }),
+      }),
   }),
 )
 
@@ -112,41 +105,35 @@ const foldGraduationYearListbox = Update.foldChild({
     evo(model, { graduationYearListbox: () => nextGraduationYearListbox }),
   toParentMessage: message =>
     Message.GotGraduationYearListboxMessage({ message }),
-  toParentOutMessage: () => Option.none(),
   foldOutMessage: foldGraduationYearListboxOutMessage,
 })
 
 export const update = (model: Model, message: Message) =>
-  Message.match<UpdateReturn>(message, {
-    UpdatedSchool: ({ value }) => [
-      evo(model, { school: () => validateSchool(value) }),
-      [],
-      Option.none(),
-    ],
-
-    UpdatedDegree: ({ value }) => [
-      evo(model, { degree: () => validateDegree(value) }),
-      [],
-      Option.none(),
-    ],
-
-    UpdatedFieldOfStudy: ({ value }) => [
-      evo(model, { fieldOfStudy: () => validateFieldOfStudy(value) }),
-      [],
-      Option.none(),
-    ],
-
-    GotGraduationYearListboxMessage: ({ message }) =>
-      foldGraduationYearListbox(model, message),
-
-    ToggledCurrentlyEnrolled: ({ isChecked }) => [
-      evo(model, { isCurrentlyEnrolled: () => isChecked }),
-      [],
-      Option.none(),
-    ],
-
-    ClickedRemoveSelf: () => [model, [], Option.some(OutMessage.Removed())],
-  })
+  Message.match<Update.ReturnWithOutMessage<Model, Message, OutMessage>>(
+    message,
+    {
+      UpdatedSchool: ({ value }) => ({
+        model: evo(model, { school: () => validateSchool(value) }),
+      }),
+
+      UpdatedDegree: ({ value }) => ({
+        model: evo(model, { degree: () => validateDegree(value) }),
+      }),
+
+      UpdatedFieldOfStudy: ({ value }) => ({
+        model: evo(model, { fieldOfStudy: () => validateFieldOfStudy(value) }),
+      }),
+
+      GotGraduationYearListboxMessage: ({ message }) =>
+        foldGraduationYearListbox(model, message),
+
+      ToggledCurrentlyEnrolled: ({ isChecked }) => ({
+        model: evo(model, { isCurrentlyEnrolled: () => isChecked }),
+      }),
+
+      ClickedRemoveSelf: () => ({ model, outMessage: OutMessage.Removed() }),
+    },
+  )
 
 // VALIDATION SUMMARY
 

package/dist/templates/examples/job-application/src/step/personalInfo.ts

@@ -162,17 +162,16 @@ export const ValidateEmailAsync = Command.define('ValidateEmailAsync', {
 
 // UPDATE
 
-type UpdateReturn = readonly [Model, ReadonlyArray<Command.Command<Message>>]
+type UpdateReturn = Update.Return<Model, Message>
 
 const foldPronounsOutMessage = M.type<Listbox.OutMessage>().pipe(
   M.withReturnType<Update.Step<Model, Message>>(),
   M.tagsExhaustive({
     Selected:
       ({ value }) =>
-      model => [
-        evo(model, { maybeSelectedPronoun: () => Option.some(value) }),
-        [],
-      ],
+      model => ({
+        model: evo(model, { maybeSelectedPronoun: () => Option.some(value) }),
+      }),
   }),
 )
 
@@ -189,15 +188,13 @@ const foldAvailableDateOutMessage = M.type<DatePicker.OutMessage>().pipe(
   M.tagsExhaustive({
     SelectedDate:
       ({ date }) =>
-      model => [
-        evo(model, { maybeAvailableDate: () => Option.some(date) }),
-        [],
-      ],
-    ClearedDate: () => model => [
-      evo(model, { maybeAvailableDate: () => Option.none() }),
-      [],
-    ],
-    ChangedViewMonth: () => model => [model, []],
+      model => ({
+        model: evo(model, { maybeAvailableDate: () => Option.some(date) }),
+      }),
+    ClearedDate: () => model => ({
+      model: evo(model, { maybeAvailableDate: () => Option.none() }),
+    }),
+    ChangedViewMonth: () => model => ({ model }),
   }),
 )
 
@@ -212,63 +209,57 @@ const foldAvailableDate = Update.foldChild({
 
 export const update = (model: Model, message: Message) =>
   Message.match<UpdateReturn>(message, {
-    UpdatedFirstName: ({ value }) => [
-      evo(model, { firstName: () => validateFirstName(value) }),
-      [],
-    ],
+    UpdatedFirstName: ({ value }) => ({
+      model: evo(model, { firstName: () => validateFirstName(value) }),
+    }),
 
-    UpdatedLastName: ({ value }) => [
-      evo(model, { lastName: () => validateLastName(value) }),
-      [],
-    ],
+    UpdatedLastName: ({ value }) => ({
+      model: evo(model, { lastName: () => validateLastName(value) }),
+    }),
 
     UpdatedEmail: ({ value }) => {
       const validationId = Number.increment(model.emailValidationId)
       return M.value(validateEmail(value)).pipe(
         M.withReturnType<UpdateReturn>(),
-        M.tag('Valid', () => [
-          evo(model, {
+        M.tag('Valid', () => ({
+          model: evo(model, {
             email: () => Validating({ value }),
             emailValidationId: () => validationId,
           }),
-          [ValidateEmailAsync({ emailInput: value, validationId })],
-        ]),
-        M.orElse(syncResult => [
-          evo(model, {
+          commands: [ValidateEmailAsync({ emailInput: value, validationId })],
+        })),
+        M.orElse(syncResult => ({
+          model: evo(model, {
             email: () => syncResult,
             emailValidationId: () => validationId,
           }),
-          [],
-        ]),
+        })),
       )
     },
 
     CompletedValidateEmailAsync: ({ validationId, field }) => {
       if (validationId === model.emailValidationId) {
-        return [evo(model, { email: () => field }), []]
+        return { model: evo(model, { email: () => field }) }
       } else {
-        return [model, []]
+        return { model }
       }
     },
 
-    UpdatedPhone: ({ value }) => [
-      evo(model, { phone: () => validatePhone(value) }),
-      [],
-    ],
+    UpdatedPhone: ({ value }) => ({
+      model: evo(model, { phone: () => validatePhone(value) }),
+    }),
 
     GotPronounsMessage: ({ message }) => foldPronouns(model, message),
 
-    UpdatedCustomPronouns: ({ value }) => [
-      evo(model, { customPronouns: () => value }),
-      [],
-    ],
+    UpdatedCustomPronouns: ({ value }) => ({
+      model: evo(model, { customPronouns: () => value }),
+    }),
 
-    UpdatedPortfolioUrl: ({ value }) => [
-      evo(model, {
+    UpdatedPortfolioUrl: ({ value }) => ({
+      model: evo(model, {
         portfolioUrl: () => validatePortfolioUrl(value),
       }),
-      [],
-    ],
+    }),
 
     GotAvailableDateMessage: ({ message }) => foldAvailableDate(model, message),
   })

package/dist/templates/examples/job-application/src/step/skills/entry.ts

@@ -1,5 +1,5 @@
 import { Match as M, Option, Schema as S } from 'effect'
-import { Command, Update } from 'foldkit'
+import { Update } from 'foldkit'
 import {
   Field,
   NotValidated,
@@ -73,12 +73,6 @@ export const init = (entryId: string): Model => ({
 
 // UPDATE
 
-type UpdateReturn = readonly [
-  Model,
-  ReadonlyArray<Command.Command<Message>>,
-  Option.Option<OutMessage>,
-]
-
 const foldProficiencyRadioGroupOutMessage = M.type<
   RadioGroup.OutMessage<ProficiencyLevel.ProficiencyLevel>
 >().pipe(
@@ -86,7 +80,7 @@ const foldProficiencyRadioGroupOutMessage = M.type<
   M.tagsExhaustive({
     Selected:
       ({ value }) =>
-      model => [evo(model, { proficiency: () => value }), []],
+      model => ({ model: evo(model, { proficiency: () => value }) }),
   }),
 )
 
@@ -98,22 +92,22 @@ const foldProficiencyRadioGroup = Update.foldChild({
   toParentMessage: message =>
     Message.GotProficiencyRadioGroupMessage({ message }),
   foldOutMessage: foldProficiencyRadioGroupOutMessage,
-  toParentOutMessage: () => Option.none(),
 })
 
 export const update = (model: Model, message: Message) =>
-  Message.match<UpdateReturn>(message, {
-    UpdatedName: ({ value }) => [
-      evo(model, { name: () => validateName(value) }),
-      [],
-      Option.none(),
-    ],
-
-    GotProficiencyRadioGroupMessage: ({ message }) =>
-      foldProficiencyRadioGroup(model, message),
-
-    ClickedRemoveSelf: () => [model, [], Option.some(OutMessage.Removed())],
-  })
+  Message.match<Update.ReturnWithOutMessage<Model, Message, OutMessage>>(
+    message,
+    {
+      UpdatedName: ({ value }) => ({
+        model: evo(model, { name: () => validateName(value) }),
+      }),
+
+      GotProficiencyRadioGroupMessage: ({ message }) =>
+        foldProficiencyRadioGroup(model, message),
+
+      ClickedRemoveSelf: () => ({ model, outMessage: OutMessage.Removed() }),
+    },
+  )
 
 // VALIDATION SUMMARY
 

package/dist/templates/examples/job-application/src/step/skills/skills.ts

@@ -51,20 +51,17 @@ export const GenerateEntryId = Command.define('GenerateEntryId', {
 
 // UPDATE
 
-type UpdateReturn = readonly [Model, ReadonlyArray<Command.Command<Message>>]
-
 const foldEntryOutMessage: (
   entryId: string,
 ) => (outMessage: Entry.OutMessage) => Update.Step<Model, Message> = entryId =>
   M.type<Entry.OutMessage>().pipe(
     M.withReturnType<Update.Step<Model, Message>>(),
     M.tagsExhaustive({
-      Removed: () => model => [
-        evo(model, {
+      Removed: () => model => ({
+        model: evo(model, {
           entries: Array.filter(entry => entry.id !== entryId),
         }),
-        [],
-      ],
+      }),
     }),
   )
 
@@ -82,24 +79,22 @@ const foldEntry = (entryId: string) =>
   })
 
 export const update = (model: Model, message: Message) =>
-  Message.match<UpdateReturn>(message, {
-    ClickedAddEntry: () => [model, [GenerateEntryId()]],
+  Message.match<Update.Return<Model, Message>>(message, {
+    ClickedAddEntry: () => ({ model, commands: [GenerateEntryId()] }),
 
-    SucceededGenerateEntryId: ({ entryId }) => [
-      evo(model, {
+    SucceededGenerateEntryId: ({ entryId }) => ({
+      model: evo(model, {
         entries: Array.append(Entry.init(entryId)),
       }),
-      [],
-    ],
+    }),
 
-    FailedGenerateEntryId: () => [model, []],
+    FailedGenerateEntryId: () => ({ model }),
 
-    RemovedEntry: ({ entryId }) => [
-      evo(model, {
+    RemovedEntry: ({ entryId }) => ({
+      model: evo(model, {
         entries: Array.filter(entry => entry.id !== entryId),
       }),
-      [],
-    ],
+    }),
 
     GotEntryMessage: ({ entryId, message }) =>
       foldEntry(entryId)(model, message),

package/dist/templates/examples/job-application/src/step/workHistory/entry.ts

@@ -1,5 +1,5 @@
 import { Match as M, Option, Schema as S } from 'effect'
-import { Command, Update } from 'foldkit'
+import { Update } from 'foldkit'
 import { CalendarDate } from 'foldkit/calendar'
 import {
   Field,
@@ -84,32 +84,24 @@ export const init = (entryId: string, today: CalendarDate): Model => ({
 
 // UPDATE
 
-type UpdateReturn = readonly [
-  Model,
-  ReadonlyArray<Command.Command<Message>>,
-  Option.Option<OutMessage>,
-]
-
 const foldStartDateOutMessage = M.type<DatePicker.OutMessage>().pipe(
   M.withReturnType<Update.Step<Model, Message>>(),
   M.tagsExhaustive({
-    ChangedViewMonth: () => model => [model, []],
+    ChangedViewMonth: () => model => ({ model }),
     SelectedDate:
       ({ date }) =>
-      model => [
-        evo(model, {
+      model => ({
+        model: evo(model, {
           maybeStartDate: () => Option.some(date),
           endDate: DatePicker.reflectMinDate(Option.some(date)),
         }),
-        [],
-      ],
-    ClearedDate: () => model => [
-      evo(model, {
+      }),
+    ClearedDate: () => model => ({
+      model: evo(model, {
         maybeStartDate: () => Option.none(),
         endDate: DatePicker.reflectMinDate(Option.none()),
       }),
-      [],
-    ],
+    }),
   }),
 )
 
@@ -119,30 +111,27 @@ const foldStartDate = Update.foldChild({
   write: (model, nextStartDate) =>
     evo(model, { startDate: () => nextStartDate }),
   toParentMessage: message => Message.GotStartDateMessage({ message }),
-  toParentOutMessage: () => Option.none(),
   foldOutMessage: foldStartDateOutMessage,
 })
 
 const foldEndDateOutMessage = M.type<DatePicker.OutMessage>().pipe(
   M.withReturnType<Update.Step<Model, Message>>(),
   M.tagsExhaustive({
-    ChangedViewMonth: () => model => [model, []],
+    ChangedViewMonth: () => model => ({ model }),
     SelectedDate:
       ({ date }) =>
-      model => [
-        evo(model, {
+      model => ({
+        model: evo(model, {
           maybeEndDate: () => Option.some(date),
           startDate: DatePicker.reflectMaxDate(Option.some(date)),
         }),
-        [],
-      ],
-    ClearedDate: () => model => [
-      evo(model, {
+      }),
+    ClearedDate: () => model => ({
+      model: evo(model, {
         maybeEndDate: () => Option.none(),
         startDate: DatePicker.reflectMaxDate(Option.none()),
       }),
-      [],
-    ],
+    }),
   }),
 )
 
@@ -151,42 +140,36 @@ const foldEndDate = Update.foldChild({
   read: (model: Model) => Option.some(model.endDate),
   write: (model, nextEndDate) => evo(model, { endDate: () => nextEndDate }),
   toParentMessage: message => Message.GotEndDateMessage({ message }),
-  toParentOutMessage: () => Option.none(),
   foldOutMessage: foldEndDateOutMessage,
 })
 
 export const update = (model: Model, message: Message) =>
-  Message.match<UpdateReturn>(message, {
-    UpdatedCompany: ({ value }) => [
-      evo(model, { company: () => validateCompany(value) }),
-      [],
-      Option.none(),
-    ],
-
-    UpdatedTitle: ({ value }) => [
-      evo(model, { title: () => validateTitle(value) }),
-      [],
-      Option.none(),
-    ],
-
-    GotStartDateMessage: ({ message }) => foldStartDate(model, message),
-
-    GotEndDateMessage: ({ message }) => foldEndDate(model, message),
-
-    ToggledCurrentlyEmployed: ({ isChecked }) => [
-      evo(model, { isCurrentlyEmployed: () => isChecked }),
-      [],
-      Option.none(),
-    ],
-
-    UpdatedDescription: ({ value }) => [
-      evo(model, { description: () => value }),
-      [],
-      Option.none(),
-    ],
-
-    ClickedRemoveSelf: () => [model, [], Option.some(OutMessage.Removed())],
-  })
+  Message.match<Update.ReturnWithOutMessage<Model, Message, OutMessage>>(
+    message,
+    {
+      UpdatedCompany: ({ value }) => ({
+        model: evo(model, { company: () => validateCompany(value) }),
+      }),
+
+      UpdatedTitle: ({ value }) => ({
+        model: evo(model, { title: () => validateTitle(value) }),
+      }),
+
+      GotStartDateMessage: ({ message }) => foldStartDate(model, message),
+
+      GotEndDateMessage: ({ message }) => foldEndDate(model, message),
+
+      ToggledCurrentlyEmployed: ({ isChecked }) => ({
+        model: evo(model, { isCurrentlyEmployed: () => isChecked }),
+      }),
+
+      UpdatedDescription: ({ value }) => ({
+        model: evo(model, { description: () => value }),
+      }),
+
+      ClickedRemoveSelf: () => ({ model, outMessage: OutMessage.Removed() }),
+    },
+  )
 
 // VALIDATION SUMMARY
 

package/dist/templates/examples/job-application/src/step/workHistory/workHistory.ts

@@ -54,20 +54,17 @@ export const GenerateEntryId = Command.define('GenerateEntryId', {
 
 // UPDATE
 
-type UpdateReturn = readonly [Model, ReadonlyArray<Command.Command<Message>>]
-
 const foldEntryOutMessage: (
   entryId: string,
 ) => (outMessage: Entry.OutMessage) => Update.Step<Model, Message> = entryId =>
   M.type<Entry.OutMessage>().pipe(
     M.withReturnType<Update.Step<Model, Message>>(),
     M.tagsExhaustive({
-      Removed: () => model => [
-        evo(model, {
+      Removed: () => model => ({
+        model: evo(model, {
           entries: Array.filter(entry => entry.id !== entryId),
         }),
-        [],
-      ],
+      }),
     }),
   )
 
@@ -85,24 +82,22 @@ const foldEntry = (entryId: string) =>
   })
 
 export const update = (model: Model, message: Message) =>
-  Message.match<UpdateReturn>(message, {
-    ClickedAddEntry: () => [model, [GenerateEntryId()]],
+  Message.match<Update.Return<Model, Message>>(message, {
+    ClickedAddEntry: () => ({ model, commands: [GenerateEntryId()] }),
 
-    SucceededGenerateEntryId: ({ entryId }) => [
-      evo(model, {
+    SucceededGenerateEntryId: ({ entryId }) => ({
+      model: evo(model, {
         entries: Array.append(Entry.init(entryId, model.today)),
       }),
-      [],
-    ],
+    }),
 
-    FailedGenerateEntryId: () => [model, []],
+    FailedGenerateEntryId: () => ({ model }),
 
-    RemovedEntry: ({ entryId }) => [
-      evo(model, {
+    RemovedEntry: ({ entryId }) => ({
+      model: evo(model, {
         entries: Array.filter(entry => entry.id !== entryId),
       }),
-      [],
-    ],
+    }),
 
     GotEntryMessage: ({ entryId, message }) =>
       foldEntry(entryId)(model, message),