create-foldkit-app 0.29.0 → 0.29.1

package/dist/templates/examples/job-application/src/update.ts

@@ -1,5 +1,5 @@
 import { Array, Match as M, Option, pipe } from 'effect'
-import { Command, Update } from 'foldkit'
+import { Update } from 'foldkit'
 import { evo } from 'foldkit/struct'
 
 import { Menu, Tabs } from '@foldkit/ui'
@@ -26,8 +26,6 @@ const isApplicationComplete = (model: Model): boolean =>
   Education.isComplete(model.education) &&
   Skills.isComplete(model.skills)
 
-type UpdateReturn = readonly [Model, ReadonlyArray<Command.Command<Message>>]
-
 const toNextStep = (current: Step.Step): Step.Step =>
   pipe(
     Step.all,
@@ -94,7 +92,7 @@ const foldStepMenuOutMessage = M.type<Menu.OutMessage<Step.Step>>().pipe(
   M.tagsExhaustive({
     Selected:
       ({ value }) =>
-      model => [evo(model, { currentStep: () => value }), []],
+      model => ({ model: evo(model, { currentStep: () => value }) }),
   }),
 )
 
@@ -111,7 +109,7 @@ const foldStepTabsOutMessage = M.type<Tabs.OutMessage<Step.Step>>().pipe(
   M.tagsExhaustive({
     Selected:
       ({ value }) =>
-      model => [evo(model, { currentStep: () => value }), []],
+      model => ({ model: evo(model, { currentStep: () => value }) }),
   }),
 )
 
@@ -124,7 +122,7 @@ const foldStepTabs = Update.foldChild({
 })
 
 export const update = (model: Model, message: Message) =>
-  Message.match<UpdateReturn>(message, {
+  Message.match<Update.Return<Model, Message>>(message, {
     GotPersonalInfoMessage: ({ message }) => foldPersonalInfo(model, message),
 
     GotWorkHistoryMessage: ({ message }) => foldWorkHistory(model, message),
@@ -141,18 +139,19 @@ export const update = (model: Model, message: Message) =>
 
     GotStepTabsMessage: ({ message }) => foldStepTabs(model, message),
 
-    NavigatedToStep: ({ step }) => [
-      evo(model, { currentStep: () => step }),
-      [],
-    ],
+    NavigatedToStep: ({ step }) => ({
+      model: evo(model, { currentStep: () => step }),
+    }),
+
+    ClickedNext: () => ({ model: evo(model, { currentStep: toNextStep }) }),
 
-    ClickedNext: () => [evo(model, { currentStep: toNextStep }), []],
+    ClickedPrevious: () => ({
+      model: evo(model, { currentStep: toPreviousStep }),
+    }),
 
-    ClickedPrevious: () => [evo(model, { currentStep: toPreviousStep }), []],
-    ToggledPreview: () => [
-      evo(model, { isPreviewVisible: isVisible => !isVisible }),
-      [],
-    ],
+    ToggledPreview: () => ({
+      model: evo(model, { isPreviewVisible: isVisible => !isVisible }),
+    }),
 
     ClickedSubmit: () => {
       const revealedModel = evo(model, {
@@ -163,21 +162,19 @@ export const update = (model: Model, message: Message) =>
         isSubmitAttempted: () => true,
       })
       if (isApplicationComplete(revealedModel)) {
-        return [
-          evo(revealedModel, { submission: () => Submitting() }),
-          [SubmitApplication()],
-        ]
+        return {
+          model: evo(revealedModel, { submission: () => Submitting() }),
+          commands: [SubmitApplication()],
+        }
       }
-      return [revealedModel, []]
+      return { model: revealedModel }
     },
 
-    SucceededSubmitApplication: () => [
-      evo(model, { submission: () => SubmitSuccess() }),
-      [],
-    ],
+    SucceededSubmitApplication: () => ({
+      model: evo(model, { submission: () => SubmitSuccess() }),
+    }),
 
-    FailedSubmitApplication: ({ error }) => [
-      evo(model, { submission: () => SubmitError({ error }) }),
-      [],
-    ],
+    FailedSubmitApplication: ({ error }) => ({
+      model: evo(model, { submission: () => SubmitError({ error }) }),
+    }),
   })

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

@@ -41,16 +41,15 @@ export const init: Runtime.ApplicationInit<Model, Message, Flags> = flags => {
     onSome: ({ columns }) => columns,
   })
 
-  return [
-    {
+  return {
+    model: {
       columns,
       dragAndDrop: DragAndDrop.init({ id: 'kanban' }),
       maybeNewCardColumnId: Option.none(),
       newCardTitle: '',
       announcement: '',
     },
-    [],
-  ]
+  }
 }
 
 export { Message, Model, subscriptions, update, view }

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

@@ -1,5 +1,5 @@
 import { Array, Match as M, Option, String, pipe } from 'effect'
-import { Command, Update } from 'foldkit'
+import { Update } from 'foldkit'
 import { evo } from 'foldkit/struct'
 
 import { DragAndDrop } from '@foldkit/ui'
@@ -9,7 +9,7 @@ import { Column } from './domain'
 import { Message } from './message'
 import type { Model } from './model'
 
-type UpdateReturn = readonly [Model, ReadonlyArray<Command.Command<Message>>]
+type UpdateReturn = Update.Return<Model, Message>
 
 const findCardTitle = (
   columns: ReadonlyArray<Column.Column>,
@@ -106,22 +106,21 @@ const foldDragAndDropOutMessage: (
           toContainerId,
           toIndex,
         )
-        return [
-          evo(model, {
+        return {
+          model: evo(model, {
             columns: () => nextColumns,
             announcement: () =>
               screenReaderTextForDrop(previousModel, outMessage),
           }),
-          [SaveBoard({ columns: nextColumns })],
-        ]
+          commands: [SaveBoard({ columns: nextColumns })],
+        }
       },
-      Cancelled: () => [
-        evo(model, {
+      Cancelled: () => ({
+        model: evo(model, {
           announcement: () =>
             screenReaderTextForDrop(previousModel, outMessage),
         }),
-        [],
-      ],
+      }),
     })
 
 const foldDragAndDrop = (previousModel: Model) =>
@@ -142,29 +141,31 @@ export const update = (model: Model, message: Message) =>
     GotDragAndDropMessage: ({ message }) =>
       foldDragAndDrop(model)(model, message),
 
-    ClickedAddCard: ({ columnId }) => [
-      evo(model, {
+    ClickedAddCard: ({ columnId }) => ({
+      model: evo(model, {
         maybeNewCardColumnId: () => Option.some(columnId),
         newCardTitle: () => '',
       }),
-      [FocusAddCardInput()],
-    ],
+      commands: [FocusAddCardInput()],
+    }),
 
-    ChangedNewCardTitle: ({ value }) => [
-      evo(model, { newCardTitle: () => value }),
-      [],
-    ],
+    ChangedNewCardTitle: ({ value }) => ({
+      model: evo(model, { newCardTitle: () => value }),
+    }),
 
     SubmittedNewCard: () =>
       Option.match(model.maybeNewCardColumnId, {
-        onNone: () => [model, []],
+        onNone: () => ({ model }),
         onSome: columnId => {
           const title = String.trim(model.newCardTitle)
           if (String.isEmpty(title)) {
-            return [model, []]
+            return { model }
           }
 
-          return [model, [GenerateCardId({ columnId: columnId, title: title })]]
+          return {
+            model,
+            commands: [GenerateCardId({ columnId, title })],
+          }
         },
       }),
 
@@ -181,25 +182,24 @@ export const update = (model: Model, message: Message) =>
         })
       })
 
-      return [
-        evo(model, {
+      return {
+        model: evo(model, {
           columns: () => nextColumns,
           maybeNewCardColumnId: () => Option.none(),
           newCardTitle: () => '',
         }),
-        [SaveBoard({ columns: nextColumns })],
-      ]
+        commands: [SaveBoard({ columns: nextColumns })],
+      }
     },
 
-    CancelledNewCard: () => [
-      evo(model, {
+    CancelledNewCard: () => ({
+      model: evo(model, {
         maybeNewCardColumnId: () => Option.none(),
         newCardTitle: () => '',
       }),
-      [],
-    ],
+    }),
 
-    CompletedSaveBoard: () => [model, []],
+    CompletedSaveBoard: () => ({ model }),
 
-    CompletedFocusAddCardInput: () => [model, []],
+    CompletedFocusAddCardInput: () => ({ model }),
   })

package/dist/templates/examples/managed-resource-layer/src/main.ts

@@ -8,7 +8,7 @@ import {
   Option,
   Schema as S,
 } from 'effect'
-import { Command, ManagedResource, Runtime } from 'foldkit'
+import { Command, ManagedResource, Runtime, type Update } from 'foldkit'
 import { Document, Html, HtmlBuilder } from 'foldkit/html'
 import { defineMessageUnion } from 'foldkit/message'
 import { ts } from 'foldkit/schema'
@@ -100,54 +100,50 @@ export const Compute = Command.define('Compute', {
 
 // UPDATE
 
-type UpdateReturn = readonly [
-  Model,
-  ReadonlyArray<Command.Command<Message, never, EngineService>>,
-]
-
 export const update = (model: Model, message: Message) =>
-  Message.match<UpdateReturn>(message, {
-    ClickedStartEngine: () => [
-      evo(model, { engine: () => EngineBooting() }),
-      [],
-    ],
+  Message.match<Update.Return<Model, Message, EngineService>>(message, {
+    ClickedStartEngine: () => ({
+      model: evo(model, { engine: () => EngineBooting() }),
+    }),
 
-    ClickedStopEngine: () => [evo(model, { engine: () => EngineOff() }), []],
+    ClickedStopEngine: () => ({
+      model: evo(model, { engine: () => EngineOff() }),
+    }),
 
-    StartedEngine: ({ engineId }) => [
-      evo(model, { engine: () => EngineReady({ engineId }) }),
-      [],
-    ],
+    StartedEngine: ({ engineId }) => ({
+      model: evo(model, { engine: () => EngineReady({ engineId }) }),
+    }),
 
-    StoppedEngine: () => [model, []],
+    StoppedEngine: () => ({ model }),
 
-    FailedStartEngine: ({ reason }) => [
-      evo(model, { engine: () => EngineFailed({ reason }) }),
-      [],
-    ],
+    FailedStartEngine: ({ reason }) => ({
+      model: evo(model, { engine: () => EngineFailed({ reason }) }),
+    }),
 
     ClickedCompute: () => {
       const nextComputeCount = Number.increment(model.computeCount)
-      return [
-        evo(model, { computeCount: () => nextComputeCount }),
-        [Compute({ value: nextComputeCount })],
-      ]
+      return {
+        model: evo(model, { computeCount: () => nextComputeCount }),
+        commands: [Compute({ value: nextComputeCount })],
+      }
     },
 
-    CompletedCompute: ({ result }) => [
-      evo(model, { maybeSquareResult: () => Option.some(result) }),
-      [],
-    ],
+    CompletedCompute: ({ result }) => ({
+      model: evo(model, { maybeSquareResult: () => Option.some(result) }),
+    }),
 
-    SkippedCompute: () => [model, []],
+    SkippedCompute: () => ({ model }),
   })
 
 // INIT
 
-export const init: Runtime.ApplicationInit<Model, Message> = () => [
-  { engine: EngineOff(), computeCount: 0, maybeSquareResult: Option.none() },
-  [],
-]
+export const init: Runtime.ApplicationInit<Model, Message> = () => ({
+  model: {
+    engine: EngineOff(),
+    computeCount: 0,
+    maybeSquareResult: Option.none(),
+  },
+})
 
 // MANAGED RESOURCE
 

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

@@ -11,7 +11,7 @@ import {
   Stream,
   String,
 } from 'effect'
-import { Command, Mount, Runtime, Subscription } from 'foldkit'
+import { Command, Mount, Runtime, Subscription, type Update } from 'foldkit'
 import * as Dom from 'foldkit/dom'
 import type { Document, Html } from 'foldkit/html'
 import { HtmlBuilder } from 'foldkit/html'
@@ -205,8 +205,6 @@ export const UnlockBodyScroll = Command.define('UnlockBodyScroll', {
 
 // UPDATE
 
-type UpdateReturn = readonly [Model, ReadonlyArray<Command.Command<Message>>]
-
 const findLocation = (
   model: Model,
   locationId: string,
@@ -214,68 +212,63 @@ const findLocation = (
   Array.findFirst(model.locations, ({ id }) => Equal.equals(id, locationId))
 
 export const update = (model: Model, message: Message) =>
-  Message.match<UpdateReturn>(message, {
-    SucceededMountMap: ({ hostId }) => [
-      evo(model, { maybeMapHostId: () => Option.some(hostId) }),
-      [],
-    ],
+  Message.match<Update.Return<Model, Message>>(message, {
+    SucceededMountMap: ({ hostId }) => ({
+      model: evo(model, { maybeMapHostId: () => Option.some(hostId) }),
+    }),
 
-    FailedMountMap: ({ reason }) => [
-      evo(model, { maybeMapError: () => Option.some(reason) }),
-      [],
-    ],
+    FailedMountMap: ({ reason }) => ({
+      model: evo(model, { maybeMapError: () => Option.some(reason) }),
+    }),
 
-    MovedMap: ({ bounds }) => [
-      evo(model, { maybeBounds: () => Option.some(bounds) }),
-      [],
-    ],
+    MovedMap: ({ bounds }) => ({
+      model: evo(model, { maybeBounds: () => Option.some(bounds) }),
+    }),
 
-    ClickedMarker: ({ locationId }) => [
-      evo(model, {
+    ClickedMarker: ({ locationId }) => ({
+      model: evo(model, {
         maybeSelectedLocationId: () => Option.some(locationId),
       }),
-      [],
-    ],
+    }),
 
     ClickedLocation: ({ locationId }) =>
       Option.match(findLocation(model, locationId), {
-        onNone: () => [model, []],
-        onSome: ({ lng, lat }) => [
-          evo(model, {
+        onNone: () => ({ model }),
+        onSome: ({ lng, lat }) => ({
+          model: evo(model, {
             maybeSelectedLocationId: () => Option.some(locationId),
           }),
-          [
+          commands: [
             FlyTo({
               maybeHostId: model.maybeMapHostId,
-              lng: lng,
-              lat: lat,
+              lng,
+              lat,
               zoom: SELECTED_LOCATION_ZOOM,
             }),
           ],
-        ],
+        }),
       }),
 
-    UpdatedSearchQuery: ({ value }) => [
-      evo(model, { searchQuery: () => value }),
-      [],
-    ],
+    UpdatedSearchQuery: ({ value }) => ({
+      model: evo(model, { searchQuery: () => value }),
+    }),
 
-    ClickedFindMe: () => [
-      evo(model, { geolocateState: () => GeolocateLocating() }),
-      [LockBodyScroll(), Geolocate()],
-    ],
+    ClickedFindMe: () => ({
+      model: evo(model, { geolocateState: () => GeolocateLocating() }),
+      commands: [LockBodyScroll(), Geolocate()],
+    }),
 
-    DismissedGeolocate: () => [
-      evo(model, { geolocateState: () => GeolocateIdle() }),
-      [UnlockBodyScroll()],
-    ],
+    DismissedGeolocate: () => ({
+      model: evo(model, { geolocateState: () => GeolocateIdle() }),
+      commands: [UnlockBodyScroll()],
+    }),
 
-    SucceededGeolocate: ({ lng, lat }) => [
-      evo(model, {
+    SucceededGeolocate: ({ lng, lat }) => ({
+      model: evo(model, {
         maybeUserLocation: () => Option.some({ lng, lat }),
         geolocateState: () => GeolocateIdle(),
       }),
-      [
+      commands: [
         UnlockBodyScroll(),
         FlyTo({
           maybeHostId: model.maybeMapHostId,
@@ -284,24 +277,23 @@ export const update = (model: Model, message: Message) =>
           zoom: USER_LOCATION_ZOOM,
         }),
       ],
-    ],
+    }),
 
-    FailedGeolocate: ({ reason }) => [
-      evo(model, { geolocateState: () => GeolocateFailed({ reason }) }),
-      [],
-    ],
+    FailedGeolocate: ({ reason }) => ({
+      model: evo(model, { geolocateState: () => GeolocateFailed({ reason }) }),
+    }),
 
-    SucceededFlyTo: () => [model, []],
-    FailedFlyTo: () => [model, []],
-    CompletedFocusSearchInput: () => [model, []],
-    CompletedLockBodyScroll: () => [model, []],
-    CompletedUnlockBodyScroll: () => [model, []],
+    SucceededFlyTo: () => ({ model }),
+    FailedFlyTo: () => ({ model }),
+    CompletedFocusSearchInput: () => ({ model }),
+    CompletedLockBodyScroll: () => ({ model }),
+    CompletedUnlockBodyScroll: () => ({ model }),
   })
 
 // INIT
 
-export const init: Runtime.ApplicationInit<Model, Message> = () => [
-  {
+export const init: Runtime.ApplicationInit<Model, Message> = () => ({
+  model: {
     locations: featuredLocations,
     searchQuery: '',
     maybeMapHostId: Option.none(),
@@ -311,8 +303,8 @@ export const init: Runtime.ApplicationInit<Model, Message> = () => [
     maybeUserLocation: Option.none(),
     geolocateState: GeolocateIdle(),
   },
-  [FocusSearchInput()],
-]
+  commands: [FocusSearchInput()],
+})
 
 // MAP MOUNT
 

package/dist/templates/examples/pixel-art/src/comparison.bench.test.ts

@@ -60,8 +60,9 @@ const buildFoldkitHistory = (steps: number): Model => {
   for (let i = 0; i < steps; i++) {
     const x = i % GRID_SIZE
     const y = Math.floor(i / GRID_SIZE) % GRID_SIZE
-    ;[model] = update(model, Message.PressedCell({ x, y }))
-    ;[model] = update(model, Message.ReleasedMouse())
+    const pressedCell = update(model, Message.PressedCell({ x, y }))
+    const releasedMouse = update(pressedCell.model, Message.ReleasedMouse())
+    model = releasedMouse.model
   }
   return model
 }
@@ -112,8 +113,11 @@ test('benchmark', () => {
     {
       name: 'Brush stroke',
       foldkit: () => {
-        const [m] = update(foldkitModel, Message.PressedCell({ x: 5, y: 5 }))
-        update(m, Message.ReleasedMouse())
+        const pressedCell = update(
+          foldkitModel,
+          Message.PressedCell({ x: 5, y: 5 }),
+        )
+        update(pressedCell.model, Message.ReleasedMouse())
       },
       react: () => {
         const s = reducer(reactState, { type: 'PressedCell', x: 5, y: 5 })
@@ -123,12 +127,27 @@ test('benchmark', () => {
     {
       name: 'Brush drag (5 cells)',
       foldkit: () => {
-        let [m] = update(foldkitModel, Message.PressedCell({ x: 0, y: 0 }))
-        ;[m] = update(m, Message.EnteredCell({ x: 1, y: 0 }))
-        ;[m] = update(m, Message.EnteredCell({ x: 2, y: 0 }))
-        ;[m] = update(m, Message.EnteredCell({ x: 3, y: 0 }))
-        ;[m] = update(m, Message.EnteredCell({ x: 4, y: 0 }))
-        update(m, Message.ReleasedMouse())
+        let brushUpdate = update(
+          foldkitModel,
+          Message.PressedCell({ x: 0, y: 0 }),
+        )
+        brushUpdate = update(
+          brushUpdate.model,
+          Message.EnteredCell({ x: 1, y: 0 }),
+        )
+        brushUpdate = update(
+          brushUpdate.model,
+          Message.EnteredCell({ x: 2, y: 0 }),
+        )
+        brushUpdate = update(
+          brushUpdate.model,
+          Message.EnteredCell({ x: 3, y: 0 }),
+        )
+        brushUpdate = update(
+          brushUpdate.model,
+          Message.EnteredCell({ x: 4, y: 0 }),
+        )
+        update(brushUpdate.model, Message.ReleasedMouse())
       },
       react: () => {
         let s = reducer(reactState, { type: 'PressedCell', x: 0, y: 0 })
@@ -162,12 +181,14 @@ test('benchmark', () => {
     {
       name: '5\u00d7 undo + 5\u00d7 redo',
       foldkit: () => {
-        let m = foldkitWith20
+        let model = foldkitWith20
         for (let i = 0; i < 5; i++) {
-          ;[m] = update(m, Message.ClickedUndo())
+          const undo = update(model, Message.ClickedUndo())
+          model = undo.model
         }
         for (let i = 0; i < 5; i++) {
-          ;[m] = update(m, Message.ClickedRedo())
+          const redo = update(model, Message.ClickedRedo())
+          model = redo.model
         }
       },
       react: () => {

package/dist/templates/examples/pixel-art/src/main.bench.ts

@@ -36,7 +36,7 @@ const dispatch = (
   ...messages: ReadonlyArray<Parameters<typeof update>[1]>
 ): Model =>
   messages.reduce<Model>(
-    (currentModel, message) => update(currentModel, message)[0],
+    (currentModel, message) => update(currentModel, message).model,
     model,
   )
 
@@ -96,10 +96,10 @@ describe('update: undo/redo with history', () => {
   bench('5x undo then 5x redo', () => {
     let model = modelWith10Steps
     for (let i = 0; i < 5; i++) {
-      model = update(model, Message.ClickedUndo())[0]
+      model = update(model, Message.ClickedUndo()).model
     }
     for (let i = 0; i < 5; i++) {
-      model = update(model, Message.ClickedRedo())[0]
+      model = update(model, Message.ClickedRedo()).model
     }
   })
 })

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

@@ -46,8 +46,8 @@ export const flags: Effect.Effect<Flags> = Effect.gen(function* () {
 
 // INIT
 
-export const init: Runtime.ApplicationInit<Model, Message, Flags> = flags => [
-  {
+export const init: Runtime.ApplicationInit<Model, Message, Flags> = flags => ({
+  model: {
     grid: Option.match(flags.maybeSavedCanvas, {
       onNone: () => createEmptyGrid(DEFAULT_GRID_SIZE),
       onSome: ({ grid }) => grid,
@@ -79,7 +79,6 @@ export const init: Runtime.ApplicationInit<Model, Message, Flags> = flags => [
     gridSizeRadioGroup: RadioGroup.init({ id: GRID_SIZE_RADIO_GROUP_ID }),
     paletteRadioGroup: RadioGroup.init({ id: PALETTE_RADIO_GROUP_ID }),
   },
-  [],
-]
+})
 
 export { Message, Model, subscriptions, update, view }