create-foldkit-app 0.29.0 → 0.29.1

package/dist/templates/examples/auth/src/page/loggedOut/update.ts

@@ -1,17 +1,11 @@
 import { Match as M, Option } from 'effect'
-import { Command, Update } from 'foldkit'
+import { Update } from 'foldkit'
 import { evo } from 'foldkit/struct'
 
 import { Message, OutMessage } from './message'
 import { Model } from './model'
 import * as Login from './page/login'
 
-type UpdateReturn = readonly [
-  Model,
-  ReadonlyArray<Command.Command<Message>>,
-  Option.Option<OutMessage>,
-]
-
 const foldLogin = Update.foldChild({
   update: Login.update,
   read: (model: Model) => Option.some(model.loginModel),
@@ -20,13 +14,15 @@ const foldLogin = Update.foldChild({
   toParentMessage: message => Message.GotLoginMessage({ message }),
   toParentOutMessage: M.type<Login.OutMessage>().pipe(
     M.tagsExhaustive({
-      SucceededLogin: ({ session }) =>
-        Option.some(OutMessage.SucceededLogin({ session })),
+      SucceededLogin: ({ session }) => OutMessage.SucceededLogin({ session }),
     }),
   ),
 })
 
 export const update = (model: Model, message: Message) =>
-  Message.match<UpdateReturn>(message, {
-    GotLoginMessage: ({ message }) => foldLogin(model, message),
-  })
+  Message.match<Update.ReturnWithOutMessage<Model, Message, OutMessage>>(
+    message,
+    {
+      GotLoginMessage: ({ message }) => foldLogin(model, message),
+    },
+  )

package/dist/templates/examples/auth/src/update.ts

@@ -51,7 +51,7 @@ const RedirectToHome = Command.define('RedirectToHome', {
   ),
 })
 
-type UpdateReturn = readonly [Model, ReadonlyArray<Command.Command<Message>>]
+type UpdateReturn = Update.Return<Model, Message>
 const withUpdateReturn = M.withReturnType<UpdateReturn>()
 
 const foldLoggedOutOutMessage: (
@@ -61,10 +61,10 @@ const foldLoggedOutOutMessage: (
   M.tagsExhaustive({
     SucceededLogin:
       ({ session }) =>
-      () => [
-        LoggedIn.init(DashboardRoute(), session),
-        [SaveSession({ session }), RedirectToDashboard()],
-      ],
+      () => ({
+        model: LoggedIn.init(DashboardRoute(), session),
+        commands: [SaveSession({ session }), RedirectToDashboard()],
+      }),
   }),
 )
 
@@ -87,10 +87,10 @@ const foldLoggedInOutMessage: (
 ) => Update.Step<Model, Message> = M.type<LoggedIn.OutMessage>().pipe(
   M.withReturnType<Update.Step<Model, Message>>(),
   M.tagsExhaustive({
-    RequestedLogout: () => () => [
-      LoggedOut.init(HomeRoute()),
-      [ClearSession(), RedirectToHome()],
-    ],
+    RequestedLogout: () => () => ({
+      model: LoggedOut.init(HomeRoute()),
+      commands: [ClearSession(), RedirectToHome()],
+    }),
   }),
 )
 
@@ -108,72 +108,66 @@ const foldLoggedIn = Update.foldChild({
   foldOutMessage: foldLoggedInOutMessage,
 })
 
-export const update = (model: Model, message: Message): UpdateReturn =>
-  M.value(message).pipe(
-    withUpdateReturn,
-    M.tags({
-      ClickedLink: ({ request }) =>
-        M.value(request).pipe(
-          withUpdateReturn,
-          M.tagsExhaustive({
-            Internal: ({ url }) => [
-              model,
-              [NavigateInternal({ url: urlToString(url) })],
-            ],
-            External: ({ href }) => [model, [LoadExternal({ href })]],
+export const update = (model: Model, message: Message) =>
+  Message.match<UpdateReturn>(message, {
+    ClickedLink: ({ request }) =>
+      M.value(request).pipe(
+        withUpdateReturn,
+        M.tagsExhaustive({
+          Internal: ({ url }) => ({
+            model,
+            commands: [NavigateInternal({ url: urlToString(url) })],
           }),
-        ),
-
-      ChangedUrl: ({ url }) => {
-        const route = urlToAppRoute(url)
-
-        return M.value(model).pipe(
-          withUpdateReturn,
-          M.tagsExhaustive({
-            LoggedOut: loggedOutModel =>
-              M.value(route).pipe(
-                withUpdateReturn,
-                M.tag('Home', 'Login', 'NotFound', route => [
-                  evo(loggedOutModel, { route: () => route }),
-                  [],
-                ]),
-                M.orElse(() => [model, [RedirectToLogin()]]),
-              ),
-
-            LoggedIn: loggedInModel =>
-              M.value(route).pipe(
-                withUpdateReturn,
-                M.tag('Dashboard', 'Settings', 'NotFound', route => [
-                  evo(loggedInModel, { route: () => route }),
-                  [],
-                ]),
-                M.orElse(() => [model, [RedirectToDashboard()]]),
-              ),
+          External: ({ href }) => ({
+            model,
+            commands: [LoadExternal({ href })],
           }),
-        )
-      },
-
-      FailedSaveSession: ({ error }) => [
-        model,
-        [LogError({ entries: ['Failed to save session:', error] })],
-      ],
+        }),
+      ),
+
+    ChangedUrl: ({ url }) => {
+      const route = urlToAppRoute(url)
+
+      return M.value(model).pipe(
+        withUpdateReturn,
+        M.tagsExhaustive({
+          LoggedOut: loggedOutModel =>
+            M.value(route).pipe(
+              withUpdateReturn,
+              M.tag('Home', 'Login', 'NotFound', route => ({
+                model: evo(loggedOutModel, { route: () => route }),
+              })),
+              M.orElse(() => ({ model, commands: [RedirectToLogin()] })),
+            ),
+
+          LoggedIn: loggedInModel =>
+            M.value(route).pipe(
+              withUpdateReturn,
+              M.tag('Dashboard', 'Settings', 'NotFound', route => ({
+                model: evo(loggedInModel, { route: () => route }),
+              })),
+              M.orElse(() => ({ model, commands: [RedirectToDashboard()] })),
+            ),
+        }),
+      )
+    },
+
+    FailedSaveSession: ({ error }) => ({
+      model,
+      commands: [LogError({ entries: ['Failed to save session:', error] })],
+    }),
 
-      FailedClearSession: ({ error }) => [
-        model,
-        [LogError({ entries: ['Failed to clear session:', error] })],
-      ],
+    FailedClearSession: ({ error }) => ({
+      model,
+      commands: [LogError({ entries: ['Failed to clear session:', error] })],
+    }),
 
-      GotLoggedOutMessage: ({ message }) => foldLoggedOut(model, message),
+    GotLoggedOutMessage: ({ message }) => foldLoggedOut(model, message),
 
-      GotLoggedInMessage: ({ message }) => foldLoggedIn(model, message),
-    }),
-    M.tag(
-      'CompletedNavigateInternal',
-      'CompletedLoadExternal',
-      'CompletedLogError',
-      'SucceededSaveSession',
-      'SucceededClearSession',
-      () => [model, []],
-    ),
-    M.exhaustive,
-  )
+    GotLoggedInMessage: ({ message }) => foldLoggedIn(model, message),
+    CompletedNavigateInternal: () => ({ model }),
+    CompletedLoadExternal: () => ({ model }),
+    CompletedLogError: () => ({ model }),
+    SucceededSaveSession: () => ({ model }),
+    SucceededClearSession: () => ({ model }),
+  })

package/dist/templates/examples/canvas-art/src/main.ts

@@ -7,7 +7,7 @@ import {
   Schema as S,
   pipe,
 } from 'effect'
-import { Canvas, Command, Runtime, Subscription } from 'foldkit'
+import { Canvas, Command, Runtime, Subscription, type Update } from 'foldkit'
 import { Document, Html, HtmlBuilder } from 'foldkit/html'
 import { defineMessageUnion } from 'foldkit/message'
 import { evo } from 'foldkit/struct'
@@ -75,10 +75,9 @@ export type Message = typeof Message.Type
 
 // INIT
 
-export const init: Runtime.ApplicationInit<Model, Message> = () => [
-  { balls: [], nextId: 0, isRunning: true },
-  [],
-]
+export const init: Runtime.ApplicationInit<Model, Message> = () => ({
+  model: { balls: [], nextId: 0, isRunning: true },
+})
 
 // COMMAND
 
@@ -131,37 +130,39 @@ const advanceBall =
   }
 
 export const update = (model: Model, message: Message) =>
-  Message.match<readonly [Model, ReadonlyArray<Command.Command<Message>>]>(
-    message,
-    {
-      TickedFrame: ({ deltaTime }) => [
-        evo(model, {
-          balls: Array.map(advanceBall(deltaTime / MS_PER_SECOND)),
-        }),
-        [],
-      ],
+  Message.match<Update.Return<Model, Message>>(message, {
+    TickedFrame: ({ deltaTime }) => ({
+      model: evo(model, {
+        balls: Array.map(advanceBall(deltaTime / MS_PER_SECOND)),
+      }),
+    }),
 
-      ClickedCanvas: ({ x, y }) => [model, [GenerateBall({ x, y })]],
+    ClickedCanvas: ({ x, y }) => ({
+      model,
+      commands: [GenerateBall({ x, y })],
+    }),
 
-      CompletedGenerateBall: ({ x, y, vx, vy, radius, color }) => [
-        evo(model, {
-          balls: balls => [
-            ...balls,
-            { id: model.nextId, x, y, vx, vy, radius, color },
-          ],
-          nextId: Number.increment,
+    CompletedGenerateBall: ({ x, y, vx, vy, radius, color }) => ({
+      model: evo(model, {
+        balls: Array.append({
+          id: model.nextId,
+          x,
+          y,
+          vx,
+          vy,
+          radius,
+          color,
         }),
-        [],
-      ],
+        nextId: Number.increment,
+      }),
+    }),
 
-      ClickedClear: () => [evo(model, { balls: () => [] }), []],
+    ClickedClear: () => ({ model: evo(model, { balls: () => [] }) }),
 
-      ClickedTogglePlay: () => [
-        evo(model, { isRunning: running => !running }),
-        [],
-      ],
-    },
-  )
+    ClickedTogglePlay: () => ({
+      model: evo(model, { isRunning: running => !running }),
+    }),
+  })
 
 // SUBSCRIPTION
 

package/dist/templates/examples/charting/src/init.test.ts

@@ -5,10 +5,13 @@ import { FetchTelemetry } from './command'
 import { init } from './init'
 
 test('seeds loading state and queues a telemetry fetch', () => {
-  const [model, commands] = init()
+  const init_ = init()
 
-  expect(model.telemetry._tag).toBe('Loading')
+  expect(init_.model.telemetry._tag).toBe('Loading')
   expect(
-    Array.some(commands, command => command.name === FetchTelemetry.name),
+    Array.some(
+      init_.commands ?? [],
+      command => command.name === FetchTelemetry.name,
+    ),
   ).toBe(true)
 })

package/dist/templates/examples/charting/src/init.ts

@@ -12,8 +12,8 @@ import {
   PERIOD_RADIO_GROUP_ID,
 } from './radioGroups'
 
-export const init: Runtime.ApplicationInit<Model, Message> = () => [
-  {
+export const init: Runtime.ApplicationInit<Model, Message> = () => ({
+  model: {
     telemetry: TelemetryAsyncData.Loading(),
     chartMode: 'Adoption',
     chartModeRadioGroup: RadioGroup.init({ id: CHART_MODE_RADIO_GROUP_ID }),
@@ -25,5 +25,5 @@ export const init: Runtime.ApplicationInit<Model, Message> = () => [
     maybeChartError: Option.none(),
     maybeSelectedDatumId: Option.none(),
   },
-  [FetchTelemetry()],
-]
+  commands: [FetchTelemetry()],
+})

package/dist/templates/examples/charting/src/update.ts

@@ -14,7 +14,7 @@ import {
   PeriodRadioGroup,
 } from './radioGroups'
 
-type UpdateReturn = readonly [Model, ReadonlyArray<Command.Command<Message>>]
+type UpdateReturn = Update.Return<Model, Message>
 
 const syncChart = (args: {
   maybeChartHostId: Model['maybeChartHostId']
@@ -43,11 +43,11 @@ const syncChart = (args: {
 
 const refetchTelemetry = (model: Model): UpdateReturn =>
   Option.match(AsyncData.revalidateOrLoad(model.telemetry), {
-    onNone: () => [model, []],
-    onSome: nextTelemetry => [
-      evo(model, { telemetry: () => nextTelemetry }),
-      [FetchTelemetry()],
-    ],
+    onNone: () => ({ model }),
+    onSome: nextTelemetry => ({
+      model: evo(model, { telemetry: () => nextTelemetry }),
+      commands: [FetchTelemetry()],
+    }),
   })
 
 const selectedControl =
@@ -57,9 +57,9 @@ const selectedControl =
       evo(model, { maybeSelectedDatumId: () => Option.none() }),
     )
 
-    return [
-      nextModel,
-      syncChart({
+    return {
+      model: nextModel,
+      commands: syncChart({
         maybeChartHostId: nextModel.maybeChartHostId,
         telemetry: nextModel.telemetry,
         chartMode: nextModel.chartMode,
@@ -67,7 +67,7 @@ const selectedControl =
         period: nextModel.period,
         maybeSelectedDatumId: nextModel.maybeSelectedDatumId,
       }),
-    ]
+    }
   }
 
 const foldChartModeRadioGroupOutMessage = M.type<
@@ -141,11 +141,11 @@ export const update = (model: Model, message: Message) =>
 
     ClickedRetry: () => refetchTelemetry(model),
 
-    ClickedChartDatum: ({ datumId }) => [
-      evo(model, {
+    ClickedChartDatum: ({ datumId }) => ({
+      model: evo(model, {
         maybeSelectedDatumId: () => Option.some(datumId),
       }),
-      syncChart({
+      commands: syncChart({
         maybeChartHostId: model.maybeChartHostId,
         telemetry: model.telemetry,
         chartMode: model.chartMode,
@@ -153,15 +153,15 @@ export const update = (model: Model, message: Message) =>
         period: model.period,
         maybeSelectedDatumId: Option.some(datumId),
       }),
-    ],
+    }),
 
     SucceededFetchTelemetry: ({ telemetry }) => {
       const nextModel = evo(model, {
         telemetry: () => TelemetryAsyncData.Success({ data: telemetry }),
       })
-      return [
-        nextModel,
-        syncChart({
+      return {
+        model: nextModel,
+        commands: syncChart({
           maybeChartHostId: nextModel.maybeChartHostId,
           telemetry: nextModel.telemetry,
           chartMode: nextModel.chartMode,
@@ -169,22 +169,21 @@ export const update = (model: Model, message: Message) =>
           period: nextModel.period,
           maybeSelectedDatumId: nextModel.maybeSelectedDatumId,
         }),
-      ]
+      }
     },
 
-    FailedFetchTelemetry: ({ error }) => [
-      evo(model, {
+    FailedFetchTelemetry: ({ error }) => ({
+      model: evo(model, {
         telemetry: () => AsyncData.settle(model.telemetry, Result.fail(error)),
       }),
-      [],
-    ],
+    }),
 
-    SucceededMountChart: ({ hostId }) => [
-      evo(model, {
+    SucceededMountChart: ({ hostId }) => ({
+      model: evo(model, {
         maybeChartHostId: () => Option.some(hostId),
         maybeChartError: () => Option.none(),
       }),
-      syncChart({
+      commands: syncChart({
         maybeChartHostId: Option.some(hostId),
         telemetry: model.telemetry,
         chartMode: model.chartMode,
@@ -192,26 +191,23 @@ export const update = (model: Model, message: Message) =>
         period: model.period,
         maybeSelectedDatumId: model.maybeSelectedDatumId,
       }),
-    ],
+    }),
 
-    FailedMountChart: ({ reason }) => [
-      evo(model, {
+    FailedMountChart: ({ reason }) => ({
+      model: evo(model, {
         maybeChartError: () => Option.some(reason),
       }),
-      [],
-    ],
+    }),
 
-    SucceededSyncChart: () => [
-      evo(model, {
+    SucceededSyncChart: () => ({
+      model: evo(model, {
         maybeChartError: () => Option.none(),
       }),
-      [],
-    ],
+    }),
 
-    FailedSyncChart: ({ reason }) => [
-      evo(model, {
+    FailedSyncChart: ({ reason }) => ({
+      model: evo(model, {
         maybeChartError: () => Option.some(reason),
       }),
-      [],
-    ],
+    }),
   })

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

@@ -1,5 +1,5 @@
 import { Schema as S } from 'effect'
-import { Command, Runtime } from 'foldkit'
+import { Runtime, type Update } from 'foldkit'
 import { Document, HtmlBuilder } from 'foldkit/html'
 import { defineMessageUnion } from 'foldkit/message'
 import { evo } from 'foldkit/struct'
@@ -23,21 +23,21 @@ export type Message = typeof Message.Type
 // UPDATE
 
 export const update = (model: Model, message: Message) =>
-  Message.match<readonly [Model, ReadonlyArray<Command.Command<Message>>]>(
-    message,
-    {
-      ClickedDecrement: () => [evo(model, { count: count => count - 1 }), []],
-      ClickedIncrement: () => [evo(model, { count: count => count + 1 }), []],
-      ClickedReset: () => [evo(model, { count: () => 0 }), []],
-    },
-  )
+  Message.match<Update.Return<Model, Message>>(message, {
+    ClickedDecrement: () => ({
+      model: evo(model, { count: count => count - 1 }),
+    }),
+    ClickedIncrement: () => ({
+      model: evo(model, { count: count => count + 1 }),
+    }),
+    ClickedReset: () => ({ model: evo(model, { count: () => 0 }) }),
+  })
 
 // INIT
 
-export const init: Runtime.ApplicationInit<Model, Message> = () => [
-  { count: 0 },
-  [],
-]
+export const init: Runtime.ApplicationInit<Model, Message> = () => ({
+  model: { count: 0 },
+})
 
 // VIEW
 

package/dist/templates/examples/counters/src/counter.ts

@@ -1,5 +1,5 @@
 import { Schema as S } from 'effect'
-import { Command, Submodel } from 'foldkit'
+import { Submodel, type Update } from 'foldkit'
 import { defineMessageUnion } from 'foldkit/message'
 import { evo } from 'foldkit/struct'
 
@@ -24,13 +24,14 @@ export type Message = typeof Message.Type
 // UPDATE
 
 export const update = (model: Model, message: Message) =>
-  Message.match<readonly [Model, ReadonlyArray<Command.Command<Message>>]>(
-    message,
-    {
-      ClickedDecrement: () => [evo(model, { count: count => count - 1 }), []],
-      ClickedIncrement: () => [evo(model, { count: count => count + 1 }), []],
-    },
-  )
+  Message.match<Update.Return<Model, Message>>(message, {
+    ClickedDecrement: () => ({
+      model: evo(model, { count: count => count - 1 }),
+    }),
+    ClickedIncrement: () => ({
+      model: evo(model, { count: count => count + 1 }),
+    }),
+  })
 
 // VIEW
 

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

@@ -1,5 +1,5 @@
 import { Array, Option, Schema as S, pipe } from 'effect'
-import { Command, Runtime, Update } from 'foldkit'
+import { Runtime, Update } from 'foldkit'
 import { Document, Html, HtmlBuilder } from 'foldkit/html'
 import { defineMessageUnion } from 'foldkit/message'
 import { evo } from 'foldkit/struct'
@@ -55,33 +55,28 @@ const foldCounter = (id: string) =>
   })
 
 export const update = (model: Model, message: Message) =>
-  Message.match<readonly [Model, ReadonlyArray<Command.Command<Message>>]>(
-    message,
-    {
-      ClickedAddRow: () => [
-        evo(model, {
-          rows: Array.append({
-            id: `counter-${model.nextRowId}`,
-            counter: Counter.init,
-          }),
-          nextRowId: nextRowId => nextRowId + 1,
-        }),
-        [],
-      ],
-      ClickedRemoveRow: ({ id }) => [
-        evo(model, {
-          rows: Array.filter(row => row.id !== id),
+  Message.match<Update.Return<Model, Message>>(message, {
+    ClickedAddRow: () => ({
+      model: evo(model, {
+        rows: Array.append({
+          id: `counter-${model.nextRowId}`,
+          counter: Counter.init,
         }),
-        [],
-      ],
-      GotCounterMessage: ({ id, message }) => foldCounter(id)(model, message),
-    },
-  )
+        nextRowId: nextRowId => nextRowId + 1,
+      }),
+    }),
+    ClickedRemoveRow: ({ id }) => ({
+      model: evo(model, {
+        rows: Array.filter(row => row.id !== id),
+      }),
+    }),
+    GotCounterMessage: ({ id, message }) => foldCounter(id)(model, message),
+  })
 
 // INIT
 
-export const init: Runtime.ApplicationInit<Model, Message> = () => [
-  {
+export const init: Runtime.ApplicationInit<Model, Message> = () => ({
+  model: {
     rows: [
       { id: 'counter-0', counter: Counter.init },
       { id: 'counter-1', counter: Counter.init },
@@ -89,8 +84,7 @@ export const init: Runtime.ApplicationInit<Model, Message> = () => [
     ],
     nextRowId: 3,
   },
-  [],
-]
+})
 
 // VIEW
 

package/dist/templates/examples/crash-view/src/main.ts

@@ -1,5 +1,5 @@
 import { Schema } from 'effect'
-import { Command, Runtime } from 'foldkit'
+import { Runtime, type Update } from 'foldkit'
 import { Document, HtmlBuilder } from 'foldkit/html'
 import { defineMessageUnion } from 'foldkit/message'
 
@@ -23,13 +23,15 @@ export type Message = typeof Message.Type
 export const update = (
   _model: Model,
   _message: Message,
-): readonly [Model, ReadonlyArray<Command.Command<Message>>] => {
+): Update.Return<Model, Message> => {
   throw new Error('This is a simulated crash!')
 }
 
 // INIT
 
-export const init: Runtime.ApplicationInit<Model, Message> = () => [null, []]
+export const init: Runtime.ApplicationInit<Model, Message> = () => ({
+  model: null,
+})
 
 // VIEW