create-foldkit-app 0.29.0 → 0.29.1

package/dist/templates/examples/slow-warnings/src/main.ts

@@ -7,7 +7,7 @@ import {
   Stream,
   pipe,
 } from 'effect'
-import { Command, Runtime, Subscription } from 'foldkit'
+import { Runtime, Subscription, type Update } from 'foldkit'
 import { type Document, type Html, HtmlBuilder, createLazy } from 'foldkit/html'
 import { defineMessageUnion } from 'foldkit/message'
 import { evo } from 'foldkit/struct'
@@ -160,76 +160,67 @@ const prependWarning =
   (warnings: ReadonlyArray<SlowWarning>): ReadonlyArray<SlowWarning> =>
     pipe(warnings, Array.prepend(warning), Array.take(MAX_WARNING_COUNT))
 
-type UpdateReturn = readonly [Model, ReadonlyArray<Command.Command<Message>>]
-
 export const update = (model: Model, message: Message) =>
-  Message.match<UpdateReturn>(message, {
+  Message.match<Update.Return<Model, Message>>(message, {
     ClickedRunUpdateWork: () => {
       burnCpu(UPDATE_WORK_MS)
 
-      return [
-        evo(model, {
+      return {
+        model: evo(model, {
           activeWorkload: () => 'Update',
         }),
-        [],
-      ]
+      }
     },
-    ClickedRunViewWork: () => [
-      evo(model, {
+    ClickedRunViewWork: () => ({
+      model: evo(model, {
         activeWorkload: () => 'View',
       }),
-      [],
-    ],
-    ClickedRunPatchWork: () => [
-      evo(model, {
+    }),
+    ClickedRunPatchWork: () => ({
+      model: evo(model, {
         activeWorkload: () => 'Patch',
         patchRows: () => PATCH_ROW_COUNT,
         patchRun: Number.increment,
       }),
-      [],
-    ],
-    ClickedRunSubscriptionDependenciesWork: () => [
-      evo(model, {
+    }),
+    ClickedRunSubscriptionDependenciesWork: () => ({
+      model: evo(model, {
         activeWorkload: () => 'SubscriptionDependencies',
       }),
-      [],
-    ],
-    ClickedClearWarnings: () => [
-      evo(model, {
+    }),
+    ClickedClearWarnings: () => ({
+      model: evo(model, {
         activeWorkload: () => 'Idle',
         warnings: () => [],
       }),
-      [],
-    ],
+    }),
     RecordedSlowWarning: ({ report }) => {
       const warning: SlowWarning = {
         id: model.nextWarningId,
         ...report,
       }
 
-      return [
-        evo(model, {
+      return {
+        model: evo(model, {
           activeWorkload: () => 'Idle',
           nextWarningId: Number.increment,
           warnings: prependWarning(warning),
         }),
-        [],
-      ]
+      }
     },
   })
 
 // INIT
 
-export const init: Runtime.ApplicationInit<Model, Message> = () => [
-  {
+export const init: Runtime.ApplicationInit<Model, Message> = () => ({
+  model: {
     activeWorkload: 'Idle',
     nextWarningId: 1,
     warnings: [],
     patchRows: 0,
     patchRun: 0,
   },
-  [],
-]
+})
 
 // SUBSCRIPTION
 

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

@@ -7,7 +7,7 @@ import {
   Stream,
   pipe,
 } from 'effect'
-import { Command, Runtime, Subscription } from 'foldkit'
+import { Command, Runtime, Subscription, type Update } from 'foldkit'
 import { Document, Html, HtmlBuilder } from 'foldkit/html'
 import { defineMessageUnion } from 'foldkit/message'
 import { evo } from 'foldkit/struct'
@@ -53,8 +53,8 @@ export type Message = typeof Message.Type
 export const init: Runtime.ApplicationInit<Model, Message> = () => {
   const snake = Snake.create(GAME.INITIAL_POSITION)
 
-  return [
-    {
+  return {
+    model: {
       snake,
       apple: { x: 15, y: 15 },
       direction: GAME.INITIAL_DIRECTION,
@@ -63,161 +63,153 @@ export const init: Runtime.ApplicationInit<Model, Message> = () => {
       points: 0,
       highScore: 0,
     },
-    [GenerateApplePosition({ snake: snake })],
-  ]
+    commands: [GenerateApplePosition({ snake: snake })],
+  }
 }
 
 // UPDATE
 
+type UpdateReturn = Update.Return<Model, Message>
+
 export const update = (model: Model, message: Message) =>
-  Message.match<readonly [Model, ReadonlyArray<Command.Command<Message>>]>(
-    message,
-    {
-      PressedKey: ({ key }) =>
-        M.value(key).pipe(
-          M.withReturnType<
-            readonly [Model, ReadonlyArray<Command.Command<Message>>]
-          >(),
-          M.whenOr(
-            'ArrowUp',
-            'ArrowDown',
-            'ArrowLeft',
-            'ArrowRight',
-            'w',
-            'a',
-            's',
-            'd',
-            moveKey => {
-              const nextDirection = M.value(moveKey).pipe(
-                M.withReturnType<Direction.Direction>(),
-                M.whenOr('ArrowUp', 'w', () => 'Up'),
-                M.whenOr('ArrowDown', 's', () => 'Down'),
-                M.whenOr('ArrowLeft', 'a', () => 'Left'),
-                M.whenOr('ArrowRight', 'd', () => 'Right'),
-                M.exhaustive,
-              )
-
-              if (model.gameState === 'Playing') {
-                return [
-                  evo(model, {
-                    nextDirection: () => nextDirection,
-                  }),
-                  [],
-                ]
-              } else {
-                return [model, []]
-              }
-            },
-          ),
-          M.when(' ', () => {
-            const nextGameState = M.value(model.gameState).pipe(
-              M.withReturnType<GameState>(),
-              M.when('NotStarted', () => 'Playing'),
-              M.when('Playing', () => 'Paused'),
-              M.when('Paused', () => 'Playing'),
-              M.when('GameOver', () => 'GameOver'),
+  Message.match<UpdateReturn>(message, {
+    PressedKey: ({ key }) =>
+      M.value(key).pipe(
+        M.withReturnType<UpdateReturn>(),
+        M.whenOr(
+          'ArrowUp',
+          'ArrowDown',
+          'ArrowLeft',
+          'ArrowRight',
+          'w',
+          'a',
+          's',
+          'd',
+          moveKey => {
+            const nextDirection = M.value(moveKey).pipe(
+              M.withReturnType<Direction.Direction>(),
+              M.whenOr('ArrowUp', 'w', () => 'Up'),
+              M.whenOr('ArrowDown', 's', () => 'Down'),
+              M.whenOr('ArrowLeft', 'a', () => 'Left'),
+              M.whenOr('ArrowRight', 'd', () => 'Right'),
               M.exhaustive,
             )
-            return [
-              evo(model, {
-                gameState: () => nextGameState,
-              }),
-              [],
-            ]
-          }),
-          M.when('r', () => {
-            const nextSnake = Snake.create(GAME.INITIAL_POSITION)
-
-            return [
-              evo(model, {
-                snake: () => nextSnake,
-                direction: () => GAME.INITIAL_DIRECTION,
-                nextDirection: () => GAME.INITIAL_DIRECTION,
-                gameState: () => 'NotStarted',
-                points: () => 0,
-              }),
-              [GenerateApplePosition({ snake: nextSnake })],
-            ]
-          }),
-          M.orElse(() => [model, []]),
-        ),
-
-      TickedClock: () => {
-        if (model.gameState !== 'Playing') {
-          return [model, []]
-        }
 
-        const currentDirection = Direction.isOpposite(
-          model.direction,
-          model.nextDirection,
-        )
-          ? model.direction
-          : model.nextDirection
-
-        const newHead = Position.move(model.snake[0], currentDirection)
-        const willEatApple = Position.equivalence(newHead, model.apple)
-
-        const nextSnake = willEatApple
-          ? Snake.grow(model.snake, currentDirection)
-          : Snake.move(model.snake, currentDirection)
-
-        if (Snake.hasCollision(nextSnake)) {
-          return [
-            evo(model, {
-              gameState: () => 'GameOver',
-              highScore: highScore => Math.max(model.points, highScore),
+            if (model.gameState === 'Playing') {
+              return {
+                model: evo(model, {
+                  nextDirection: () => nextDirection,
+                }),
+              }
+            } else {
+              return { model }
+            }
+          },
+        ),
+        M.when(' ', () => {
+          const nextGameState = M.value(model.gameState).pipe(
+            M.withReturnType<GameState>(),
+            M.when('NotStarted', () => 'Playing'),
+            M.when('Playing', () => 'Paused'),
+            M.when('Paused', () => 'Playing'),
+            M.when('GameOver', () => 'GameOver'),
+            M.exhaustive,
+          )
+          return {
+            model: evo(model, {
+              gameState: () => nextGameState,
             }),
-            [],
-          ]
-        }
-
-        const commands = willEatApple
-          ? [GenerateApplePosition({ snake: nextSnake })]
-          : []
+          }
+        }),
+        M.when('r', () => {
+          const nextSnake = Snake.create(GAME.INITIAL_POSITION)
+
+          return {
+            model: evo(model, {
+              snake: () => nextSnake,
+              direction: () => GAME.INITIAL_DIRECTION,
+              nextDirection: () => GAME.INITIAL_DIRECTION,
+              gameState: () => 'NotStarted',
+              points: () => 0,
+            }),
+            commands: [GenerateApplePosition({ snake: nextSnake })],
+          }
+        }),
+        M.orElse(() => ({ model })),
+      ),
 
-        return [
-          evo(model, {
-            snake: () => nextSnake,
-            direction: () => currentDirection,
-            points: points =>
-              willEatApple ? points + GAME.POINTS_PER_APPLE : points,
+    TickedClock: () => {
+      if (model.gameState !== 'Playing') {
+        return { model }
+      }
+
+      const currentDirection = Direction.isOpposite(
+        model.direction,
+        model.nextDirection,
+      )
+        ? model.direction
+        : model.nextDirection
+
+      const newHead = Position.move(model.snake[0], currentDirection)
+      const willEatApple = Position.equivalence(newHead, model.apple)
+
+      const nextSnake = willEatApple
+        ? Snake.grow(model.snake, currentDirection)
+        : Snake.move(model.snake, currentDirection)
+
+      if (Snake.hasCollision(nextSnake)) {
+        return {
+          model: evo(model, {
+            gameState: () => 'GameOver',
+            highScore: highScore => Math.max(model.points, highScore),
           }),
-          commands,
-        ]
-      },
-
-      PausedGame: () => [
-        evo(model, {
-          gameState: gameState =>
-            gameState === 'Playing' ? 'Paused' : 'Playing',
+        }
+      }
+
+      const commands = willEatApple
+        ? [GenerateApplePosition({ snake: nextSnake })]
+        : []
+
+      return {
+        model: evo(model, {
+          snake: () => nextSnake,
+          direction: () => currentDirection,
+          points: points =>
+            willEatApple ? points + GAME.POINTS_PER_APPLE : points,
         }),
-        [],
-      ],
-
-      RestartedGame: () => {
-        const startPos: Position.Position = { x: 10, y: 10 }
-        const nextSnake = Snake.create(startPos)
-
-        return [
-          evo(model, {
-            snake: () => nextSnake,
-            direction: () => 'Right',
-            nextDirection: () => 'Right',
-            gameState: () => 'NotStarted',
-            points: () => 0,
-          }),
-          [GenerateApplePosition({ snake: nextSnake })],
-        ]
-      },
+        commands,
+      }
+    },
 
-      CompletedGenerateApplePosition: ({ position }) => [
-        evo(model, {
-          apple: () => position,
+    PausedGame: () => ({
+      model: evo(model, {
+        gameState: gameState =>
+          gameState === 'Playing' ? 'Paused' : 'Playing',
+      }),
+    }),
+
+    RestartedGame: () => {
+      const startPosition: Position.Position = { x: 10, y: 10 }
+      const nextSnake = Snake.create(startPosition)
+
+      return {
+        model: evo(model, {
+          snake: () => nextSnake,
+          direction: () => 'Right',
+          nextDirection: () => 'Right',
+          gameState: () => 'NotStarted',
+          points: () => 0,
         }),
-        [],
-      ],
+        commands: [GenerateApplePosition({ snake: nextSnake })],
+      }
     },
-  )
+
+    CompletedGenerateApplePosition: ({ position }) => ({
+      model: evo(model, {
+        apple: () => position,
+      }),
+    }),
+  })
 
 // COMMAND
 

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

@@ -1,5 +1,5 @@
 import { Effect, Match as M, Schema as S } from 'effect'
-import { Command, Runtime } from 'foldkit'
+import { Command, Runtime, type Update } from 'foldkit'
 import { type Document, type Html, type HtmlBuilder } from 'foldkit/html'
 import { defineMessageUnion } from 'foldkit/message'
 import { UrlRequest, load, pushUrl } from 'foldkit/navigation'
@@ -30,10 +30,9 @@ export type Message = typeof Message.Type
 
 // INIT
 
-export const init: Runtime.RoutingApplicationInit<Model, Message> = url => [
-  { route: urlToAppRoute(url), count: 0 },
-  [],
-]
+export const init: Runtime.RoutingApplicationInit<Model, Message> = url => ({
+  model: { route: urlToAppRoute(url), count: 0 },
+})
 
 // COMMAND
 
@@ -53,29 +52,33 @@ 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>()
 
 export const update = (model: Model, message: Message) =>
   Message.match<UpdateReturn>(message, {
-    ClickedIncrement: () => [evo(model, { count: count => count + 1 }), []],
+    ClickedIncrement: () => ({
+      model: evo(model, { count: count => count + 1 }),
+    }),
     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 })],
+          }),
         }),
       ),
-    ChangedUrl: ({ url }) => [
-      evo(model, { route: () => urlToAppRoute(url) }),
-      [],
-    ],
-    CompletedNavigateInternal: () => [model, []],
-    CompletedLoadExternal: () => [model, []],
+    ChangedUrl: ({ url }) => ({
+      model: evo(model, { route: () => urlToAppRoute(url) }),
+    }),
+    CompletedNavigateInternal: () => ({ model }),
+    CompletedLoadExternal: () => ({ model }),
   })
 
 // VIEW

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

@@ -1,5 +1,5 @@
 import { Effect, Schema as S } from 'effect'
-import { Command, Runtime } from 'foldkit'
+import { Command, Runtime, type Update } from 'foldkit'
 import { type Document, type Html, type HtmlBuilder } from 'foldkit/html'
 import { defineMessageUnion } from 'foldkit/message'
 import { evo } from 'foldkit/struct'
@@ -39,26 +39,23 @@ export type Message = typeof Message.Type
 // UPDATE
 
 export const update = (model: Model, message: Message) =>
-  Message.match<readonly [Model, ReadonlyArray<Command.Command<Message>>]>(
-    message,
-    {
-      ClickedDecrement: () => {
-        const nextCount = model.count - 1
-        return [
-          evo(model, { count: () => nextCount }),
-          [PersistCount({ count: nextCount })],
-        ]
-      },
-      ClickedIncrement: () => {
-        const nextCount = model.count + 1
-        return [
-          evo(model, { count: () => nextCount }),
-          [PersistCount({ count: nextCount })],
-        ]
-      },
-      CompletedPersistCount: () => [model, []],
+  Message.match<Update.Return<Model, Message>>(message, {
+    ClickedDecrement: () => {
+      const nextCount = model.count - 1
+      return {
+        model: evo(model, { count: () => nextCount }),
+        commands: [PersistCount({ count: nextCount })],
+      }
     },
-  )
+    ClickedIncrement: () => {
+      const nextCount = model.count + 1
+      return {
+        model: evo(model, { count: () => nextCount }),
+        commands: [PersistCount({ count: nextCount })],
+      }
+    },
+    CompletedPersistCount: () => ({ model }),
+  })
 
 // COMMAND
 
@@ -78,14 +75,13 @@ export const PersistCount = Command.define('PersistCount', {
 
 // INIT
 
-export const init: Runtime.ApplicationInit<Model, Message, Flags> = flags => [
-  {
+export const init: Runtime.ApplicationInit<Model, Message, Flags> = flags => ({
+  model: {
     count: flags.initialCount,
     renderedAt: flags.renderedAt,
     renderedOn: flags.renderedOn,
   },
-  [],
-]
+})
 
 // VIEW
 

package/dist/templates/examples/state-machine/src/main.ts

@@ -334,14 +334,13 @@ export const initialModel = Model.make({
   nextTransitionLogId: 0,
 })
 
-export const init: Runtime.ApplicationInit<Model, Message> = () => [
-  initialModel,
-  [],
-]
+export const init: Runtime.ApplicationInit<Model, Message> = () => ({
+  model: initialModel,
+})
 
 // UPDATE
 
-type UpdateReturn = readonly [Model, ReadonlyArray<Command.Command<Message>>]
+type UpdateReturn = Update.Return<Model, Message>
 
 export const TRANSITION_LOG_LIMIT = 20
 
@@ -376,8 +375,8 @@ const stepMachine =
       summary: resultToTransitionSummary(result),
     }
 
-    return [
-      evo(model, {
+    return {
+      model: evo(model, {
         checkout: () => nextCheckout,
         transitionLog: flow(
           Array.prepend(transitionLogEntry),
@@ -385,8 +384,8 @@ const stepMachine =
         ),
         nextTransitionLogId: Number.increment,
       }),
-      transitionCommands,
-    ]
+      commands: transitionCommands,
+    }
   }
 
 const foldEditionRadioGroupOutMessage = M.type<RadioGroup.OutMessage>().pipe(
@@ -410,11 +409,25 @@ const foldEditionRadioGroup = Update.foldChild({
   foldOutMessage: foldEditionRadioGroupOutMessage,
 })
 
-export const update = (model: Model, message: Message): UpdateReturn =>
+export const update = (model: Model, message: Message) =>
   M.value(message).pipe(
     M.withReturnType<UpdateReturn>(),
     M.tag('GotEditionRadioGroupMessage', ({ message }) =>
       foldEditionRadioGroup(model, message),
     ),
-    M.orElse(() => stepMachine(message)(model)),
+    M.tag(
+      'ClickedContinue',
+      'ClickedBack',
+      'ClickedCancel',
+      'ClickedPlaceOrder',
+      'ClickedStartOver',
+      'ToggledPaymentMethod',
+      'SelectedEdition',
+      'ToggledTermsAccepted',
+      'UpdatedPromoCode',
+      'SubmittedPromoCode',
+      'SucceededPlaceOrder',
+      () => stepMachine(message)(model),
+    ),
+    M.exhaustive,
   )

package/dist/templates/examples/state-machine/src/story.test.ts

@@ -183,8 +183,8 @@ describe('update', () => {
         Message.SelectedEdition({ isShippingRequired: index % 2 === 0 }),
       ),
       Array.reduce(initialModel, (model, message) => {
-        const [nextModel] = update(model, message)
-        return nextModel
+        const messageUpdate = update(model, message)
+        return messageUpdate.model
       }),
     )