create-foldkit-app 0.29.0 → 0.29.1

package/dist/templates/examples/route-transitions/src/main.ts

@@ -147,8 +147,8 @@ const nextSequenceNumber = (
 
 const logTransition =
   (transition: AppTransition): Step =>
-  model => [
-    evo(model, {
+  model => ({
+    model: evo(model, {
       transitionLog: transitionLog =>
         pipe(
           transitionLog,
@@ -160,54 +160,58 @@ const logTransition =
           Array.take(MAX_LOGGED_TRANSITIONS),
         ),
     }),
-    [],
-  ]
+  })
 
 const loadCatalogOnGalleryEntry =
   (transition: AppTransition): Step =>
   model =>
     Transition.isEntering(transition, 'Gallery') &&
     model.catalogStatus !== 'Loading'
-      ? [evo(model, { catalogStatus: () => 'Loading' }), [LoadCatalog()]]
-      : [model, []]
+      ? {
+          model: evo(model, { catalogStatus: () => 'Loading' }),
+          commands: [LoadCatalog()],
+        }
+      : { model }
 
 const loadPaintingOnEntry =
   (transition: AppTransition): Step =>
   model =>
     Option.match(Transition.entered(transition, 'Painting'), {
-      onNone: () => [model, []],
-      onSome: ({ paintingId }) => [
-        evo(model, { paintingStatus: () => PaintingLoading({ paintingId }) }),
-        [LoadPainting({ paintingId })],
-      ],
+      onNone: () => ({ model }),
+      onSome: ({ paintingId }) => ({
+        model: evo(model, {
+          paintingStatus: () => PaintingLoading({ paintingId }),
+        }),
+        commands: [LoadPainting({ paintingId })],
+      }),
     })
 
 const reloadPaintingOnIdChange =
   (transition: AppTransition): Step =>
   model =>
     Option.match(Transition.stayed(transition, 'Painting'), {
-      onNone: () => [model, []],
+      onNone: () => ({ model }),
       onSome: ({ previousRoute, nextRoute }) =>
         previousRoute.paintingId === nextRoute.paintingId
-          ? [model, []]
-          : [
-              evo(model, {
+          ? { model }
+          : {
+              model: evo(model, {
                 paintingStatus: () =>
                   PaintingLoading({ paintingId: nextRoute.paintingId }),
               }),
-              [LoadPainting({ paintingId: nextRoute.paintingId })],
-            ],
+              commands: [LoadPainting({ paintingId: nextRoute.paintingId })],
+            },
     })
 
 const saveDraftOnStudioExit =
   (transition: AppTransition): Step =>
   model =>
     Option.match(Transition.exited(transition, 'Studio'), {
-      onNone: () => [model, []],
+      onNone: () => ({ model }),
       onSome: () =>
         model.studioDraft === ''
-          ? [model, []]
-          : [model, [SaveDraft({ draft: model.studioDraft })]],
+          ? { model }
+          : { model, commands: [SaveDraft({ draft: model.studioDraft })] },
     })
 
 const handleTransition = (
@@ -224,18 +228,21 @@ const handleTransition = (
 
 export const update = (model: Model, message: Message) =>
   Message.match<UpdateReturn>(message, {
-    CompletedNavigateInternal: () => [model, []],
-    CompletedLoadExternal: () => [model, []],
+    CompletedNavigateInternal: () => ({ model }),
+    CompletedLoadExternal: () => ({ model }),
 
     ClickedLink: ({ request }) =>
       M.value(request).pipe(
         withUpdateReturn,
         M.tagsExhaustive({
-          Internal: ({ url }) => [
+          Internal: ({ url }) => ({
             model,
-            [NavigateInternal({ url: urlToString(url) })],
-          ],
-          External: ({ href }) => [model, [LoadExternal({ href })]],
+            commands: [NavigateInternal({ url: urlToString(url) })],
+          }),
+          External: ({ href }) => ({
+            model,
+            commands: [LoadExternal({ href })],
+          }),
         }),
       ),
 
@@ -248,31 +255,27 @@ export const update = (model: Model, message: Message) =>
       )
     },
 
-    SucceededLoadCatalog: () => [
-      evo(model, { catalogStatus: () => 'Ready' }),
-      [],
-    ],
+    SucceededLoadCatalog: () => ({
+      model: evo(model, { catalogStatus: () => 'Ready' }),
+    }),
 
     SucceededLoadPainting: ({ paintingId }) =>
       model.paintingStatus._tag === 'PaintingLoading' &&
       model.paintingStatus.paintingId === paintingId
-        ? [
-            evo(model, {
+        ? {
+            model: evo(model, {
               paintingStatus: () => PaintingReady({ paintingId }),
             }),
-            [],
-          ]
-        : [model, []],
+          }
+        : { model },
 
-    UpdatedStudioDraft: ({ value }) => [
-      evo(model, { studioDraft: () => value }),
-      [],
-    ],
+    UpdatedStudioDraft: ({ value }) => ({
+      model: evo(model, { studioDraft: () => value }),
+    }),
 
-    SucceededSaveDraft: ({ draft }) => [
-      evo(model, { maybeSavedDraft: () => Option.some(draft) }),
-      [],
-    ],
+    SucceededSaveDraft: ({ draft }) => ({
+      model: evo(model, { maybeSavedDraft: () => Option.some(draft) }),
+    }),
   })
 
 // INIT

package/dist/templates/examples/route-transitions/src/story.test.ts

@@ -40,26 +40,26 @@ const modelOn = (route: AppRoute): Model =>
 
 describe('init', () => {
   test('a cold load into the gallery logs the transition and loads the catalog', () => {
-    const [model, commands] = init(urlOrThrow('http://localhost/gallery'))
+    const init_ = init(urlOrThrow('http://localhost/gallery'))
 
-    expect(model.route._tag).toBe('Gallery')
-    expect(model.catalogStatus).toBe('Loading')
-    expect(model.transitionLog).toHaveLength(1)
+    expect(init_.model.route._tag).toBe('Gallery')
+    expect(init_.model.catalogStatus).toBe('Loading')
+    expect(init_.model.transitionLog).toHaveLength(1)
     expect(
-      Array.map(model.transitionLog, entry => entry.maybePreviousRoute),
+      Array.map(init_.model.transitionLog, entry => entry.maybePreviousRoute),
     ).toStrictEqual([Option.none()])
-    expect(Array.map(commands, command => command.name)).toContain(
+    expect(Array.map(init_.commands ?? [], command => command.name)).toContain(
       'LoadCatalog',
     )
   })
 
   test('a cold load into the home route loads nothing', () => {
-    const [model, commands] = init(urlOrThrow('http://localhost/'))
+    const homeInit = init(urlOrThrow('http://localhost/'))
 
-    expect(model.route._tag).toBe('Home')
-    expect(model.catalogStatus).toBe('Idle')
-    expect(model.transitionLog).toHaveLength(1)
-    expect(commands).toStrictEqual([])
+    expect(homeInit.model.route._tag).toBe('Home')
+    expect(homeInit.model.catalogStatus).toBe('Idle')
+    expect(homeInit.model.transitionLog).toHaveLength(1)
+    expect(homeInit.commands ?? []).toStrictEqual([])
   })
 })
 

package/dist/templates/examples/routing/src/main.ts

@@ -69,14 +69,13 @@ export const init: Runtime.RoutingApplicationInit<Model, Message> = (
     M.orElse(() => PeopleRoute({ searchText: Option.none() })),
   )
 
-  const [peoplePage, peopleCommands] = People.init(initialPeopleRoute)
-
-  return [
-    { route, peoplePage },
-    Command.mapMessages(peopleCommands, childMessage =>
+  const peopleInit = People.init(initialPeopleRoute)
+  return {
+    model: { route, peoplePage: peopleInit.model },
+    commands: Command.mapMessages(peopleInit.commands, childMessage =>
       Message.GotPeopleMessage({ message: childMessage }),
     ),
-  ]
+  }
 }
 
 // COMMAND
@@ -97,7 +96,7 @@ const LoadExternal = Command.define('LoadExternal', {
 
 // UPDATE
 
-type UpdateReturn = readonly [Model, ReadonlyArray<Command.Command<Message>>]
+type UpdateReturn = Update.Return<Model, Message>
 const withUpdateReturn = M.withReturnType<UpdateReturn>()
 
 const foldPeopleEntry = <Input>(
@@ -117,22 +116,25 @@ const foldPeopleRouteChanged = foldPeopleEntry(People.informRouteChanged)
 
 const setRoute =
   (nextRoute: AppRoute): Update.Step<Model, Message> =>
-  model => [evo(model, { route: () => nextRoute }), []]
+  model => ({ model: evo(model, { route: () => nextRoute }) })
 
 export const update = (model: Model, message: Message) =>
   Message.match<UpdateReturn>(message, {
-    CompletedNavigateInternal: () => [model, []],
-    CompletedLoadExternal: () => [model, []],
+    CompletedNavigateInternal: () => ({ model }),
+    CompletedLoadExternal: () => ({ model }),
 
     ClickedLink: ({ request }) =>
       M.value(request).pipe(
         withUpdateReturn,
         M.tagsExhaustive({
-          Internal: ({ url }) => [
+          Internal: ({ url }) => ({
             model,
-            [NavigateInternal({ url: urlToString(url) })],
-          ],
-          External: ({ href }) => [model, [LoadExternal({ href })]],
+            commands: [NavigateInternal({ url: urlToString(url) })],
+          }),
+          External: ({ href }) => ({
+            model,
+            commands: [LoadExternal({ href })],
+          }),
         }),
       ),
 

package/dist/templates/examples/routing/src/page/people.ts

@@ -8,7 +8,7 @@ import {
   String,
   pipe,
 } from 'effect'
-import { Command, Submodel } from 'foldkit'
+import { Command, Submodel, type Update } from 'foldkit'
 import { Html, HtmlBuilder } from 'foldkit/html'
 import { defineMessageUnion } from 'foldkit/message'
 import { pushUrl } from 'foldkit/navigation'
@@ -110,18 +110,18 @@ export type Message = typeof Message.Type
 
 // INIT
 
-export const init = (
-  route: PeopleRoute,
-): readonly [Model, ReadonlyArray<Command.Command<Message>>] => {
+type InitReturn = Update.Return<Model, Message>
+
+export const init = (route: PeopleRoute): InitReturn => {
   const searchText = routeSearchText(route)
-  return [
-    {
+  return {
+    model: {
       searchInput: searchText,
       searchHistory: addSearchToHistory([], searchText),
       results: SearchLoading(),
     },
-    [FetchPeople({ searchText })],
-  ]
+    commands: [FetchPeople({ searchText })],
+  }
 }
 
 // COMMAND
@@ -151,48 +151,43 @@ export const FetchPeople = Command.define('FetchPeople', {
 
 // UPDATE
 
-export type UpdateReturn = readonly [
-  Model,
-  ReadonlyArray<Command.Command<Message>>,
-]
+export type UpdateReturn = Update.Return<Model, Message>
 
 export const update = (model: Model, message: Message) =>
   Message.match<UpdateReturn>(message, {
-    ChangedSearchInput: ({ value }) => [
-      evo(model, { searchInput: () => value }),
-      [],
-    ],
+    ChangedSearchInput: ({ value }) => ({
+      model: evo(model, { searchInput: () => value }),
+    }),
 
-    SubmittedSearch: () => [
+    SubmittedSearch: () => ({
       model,
-      [
+      commands: [
         PushSearchUrl({
           searchText: Option.fromNullishOr(model.searchInput || null),
         }),
       ],
-    ],
+    }),
 
     ChangedRoute: ({ route }) => {
       const searchText = routeSearchText(route)
-      return [
-        evo(model, {
+      return {
+        model: evo(model, {
           searchInput: () => searchText,
           searchHistory: searchHistory =>
             addSearchToHistory(searchHistory, searchText),
           results: () => SearchLoading(),
         }),
-        [FetchPeople({ searchText })],
-      ]
+        commands: [FetchPeople({ searchText })],
+      }
     },
 
-    SucceededFetchPeople: ({ query, people: fetchedPeople }) => [
-      evo(model, {
+    SucceededFetchPeople: ({ query, people: fetchedPeople }) => ({
+      model: evo(model, {
         results: () => SearchLoaded({ query, people: fetchedPeople }),
       }),
-      [],
-    ],
+    }),
 
-    CompletedPushSearchUrl: () => [model, []],
+    CompletedPushSearchUrl: () => ({ model }),
   })
 
 /** Tells the People page that the route changed. People does not own the

package/dist/templates/examples/shopping-cart/src/main.ts

@@ -51,16 +51,15 @@ export type Message = typeof Message.Type
 export const init: Runtime.RoutingApplicationInit<Model, Message> = (
   url: Url,
 ) => {
-  return [
-    {
+  return {
+    model: {
       route: urlToAppRoute(url),
       cart: [],
       deliveryInstructions: '',
       orderPlaced: false,
       productsPage: Products.init(products),
     },
-    [],
-  ]
+  }
 }
 
 // COMMAND
@@ -81,7 +80,7 @@ const LoadExternal = Command.define('LoadExternal', {
 
 // UPDATE
 
-type UpdateReturn = readonly [Model, ReadonlyArray<Command.Command<Message>>]
+type UpdateReturn = Update.Return<Model, Message>
 const withUpdateReturn = M.withReturnType<UpdateReturn>()
 
 const foldProductsOutMessage = M.type<Products.OutMessage>().pipe(
@@ -89,13 +88,17 @@ const foldProductsOutMessage = M.type<Products.OutMessage>().pipe(
   M.tagsExhaustive({
     AddedToCart:
       ({ item }) =>
-      model => [evo(model, { cart: Cart.addItem(item) }), []],
+      model => ({ model: evo(model, { cart: Cart.addItem(item) }) }),
     IncrementedQuantity:
       ({ itemId }) =>
-      model => [evo(model, { cart: Cart.incrementQuantity(itemId) }), []],
+      model => ({
+        model: evo(model, { cart: Cart.incrementQuantity(itemId) }),
+      }),
     DecrementedQuantity:
       ({ itemId }) =>
-      model => [evo(model, { cart: Cart.decrementQuantity(itemId) }), []],
+      model => ({
+        model: evo(model, { cart: Cart.decrementQuantity(itemId) }),
+      }),
   }),
 )
 
@@ -110,74 +113,70 @@ const foldProducts = Update.foldChild({
 
 export const update = (model: Model, message: Message) =>
   Message.match<UpdateReturn>(message, {
-    CompletedNavigateInternal: () => [model, []],
-    CompletedLoadExternal: () => [model, []],
+    CompletedNavigateInternal: () => ({ model }),
+    CompletedLoadExternal: () => ({ model }),
 
     ClickedLink: ({ request }) =>
       M.value(request).pipe(
         withUpdateReturn,
         M.tagsExhaustive({
-          Internal: ({ url }) => [
+          Internal: ({ url }) => ({
             model,
-            [NavigateInternal({ url: urlToString(url) })],
-          ],
+            commands: [NavigateInternal({ url: urlToString(url) })],
+          }),
 
-          External: ({ href }) => [model, [LoadExternal({ href })]],
+          External: ({ href }) => ({
+            model,
+            commands: [LoadExternal({ href })],
+          }),
         }),
       ),
 
-    ChangedUrl: ({ url }) => [
-      evo(model, {
+    ChangedUrl: ({ url }) => ({
+      model: evo(model, {
         route: () => urlToAppRoute(url),
       }),
-      [],
-    ],
+    }),
 
     GotProductsMessage: ({ message }) => foldProducts(model, message),
 
-    ClickedIncrementQuantity: ({ itemId }) => [
-      evo(model, {
+    ClickedIncrementQuantity: ({ itemId }) => ({
+      model: evo(model, {
         cart: Cart.incrementQuantity(itemId),
       }),
-      [],
-    ],
+    }),
 
-    ClickedDecrementQuantity: ({ itemId }) => [
-      evo(model, {
+    ClickedDecrementQuantity: ({ itemId }) => ({
+      model: evo(model, {
         cart: Cart.decrementQuantity(itemId),
       }),
-      [],
-    ],
+    }),
 
-    ClickedRemoveCartItem: ({ itemId }) => [
-      evo(model, {
+    ClickedRemoveCartItem: ({ itemId }) => ({
+      model: evo(model, {
         cart: Cart.removeItem(itemId),
       }),
-      [],
-    ],
+    }),
 
-    ClickedClearCart: () => [
-      evo(model, {
+    ClickedClearCart: () => ({
+      model: evo(model, {
         cart: () => [],
       }),
-      [],
-    ],
+    }),
 
-    UpdatedDeliveryInstructions: ({ value }) => [
-      evo(model, {
+    UpdatedDeliveryInstructions: ({ value }) => ({
+      model: evo(model, {
         deliveryInstructions: () => value,
       }),
-      [],
-    ],
+    }),
 
-    ClickedPlaceOrder: () => [
-      evo(model, {
+    ClickedPlaceOrder: () => ({
+      model: evo(model, {
         orderPlaced: () => true,
         cart: () => [],
         deliveryInstructions: () => '',
       }),
-      [],
-    ],
+    }),
   })
 
 // VIEW

package/dist/templates/examples/shopping-cart/src/page/products.ts

@@ -1,5 +1,5 @@
 import { Array, Effect, Option, Schema as S } from 'effect'
-import { Command, Submodel } from 'foldkit'
+import { Command, Submodel, type Update } from 'foldkit'
 import { defineMessageUnion } from 'foldkit/message'
 import { replaceUrl } from 'foldkit/navigation'
 import { evo } from 'foldkit/struct'
@@ -61,46 +61,39 @@ const ReplaceSearchUrl = Command.define('ReplaceSearchUrl', {
 
 // UPDATE
 
-type UpdateReturn = readonly [
-  Model,
-  ReadonlyArray<Command.Command<Message>>,
-  Option.Option<OutMessage>,
-]
-
 export const update = (model: Model, message: Message) =>
-  Message.match<UpdateReturn>(message, {
-    CompletedReplaceSearchUrl: () => [model, [], Option.none()],
+  Message.match<Update.ReturnWithOutMessage<Model, Message, OutMessage>>(
+    message,
+    {
+      CompletedReplaceSearchUrl: () => ({ model }),
 
-    ChangedSearchInput: ({ value }) => [
-      evo(model, { searchText: () => value }),
-      [
-        ReplaceSearchUrl({
-          url: productsRouter({
-            searchText: Option.fromNullishOr(value || null),
+      ChangedSearchInput: ({ value }) => ({
+        model: evo(model, { searchText: () => value }),
+        commands: [
+          ReplaceSearchUrl({
+            url: productsRouter({
+              searchText: Option.fromNullishOr(value || null),
+            }),
           }),
-        }),
-      ],
-      Option.none(),
-    ],
+        ],
+      }),
 
-    ClickedAddToCart: ({ item }) => [
-      model,
-      [],
-      Option.some(OutMessage.AddedToCart({ item })),
-    ],
+      ClickedAddToCart: ({ item }) => ({
+        model,
+        outMessage: OutMessage.AddedToCart({ item }),
+      }),
 
-    ClickedIncrementQuantity: ({ itemId }) => [
-      model,
-      [],
-      Option.some(OutMessage.IncrementedQuantity({ itemId })),
-    ],
+      ClickedIncrementQuantity: ({ itemId }) => ({
+        model,
+        outMessage: OutMessage.IncrementedQuantity({ itemId }),
+      }),
 
-    ClickedDecrementQuantity: ({ itemId }) => [
-      model,
-      [],
-      Option.some(OutMessage.DecrementedQuantity({ itemId })),
-    ],
-  })
+      ClickedDecrementQuantity: ({ itemId }) => ({
+        model,
+        outMessage: OutMessage.DecrementedQuantity({ itemId }),
+      }),
+    },
+  )
 
 // VIEW