create-foldkit-app 0.29.0 → 0.29.1

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

@@ -1,5 +1,5 @@
 import { Duration, Effect, Schema as S, Stream } from 'effect'
-import { Command, Port, Runtime, Subscription } from 'foldkit'
+import { Command, Port, Runtime, Subscription, type Update } from 'foldkit'
 import { Html, HtmlBuilder } from 'foldkit/html'
 import { defineMessageUnion } from 'foldkit/message'
 import { evo } from 'foldkit/struct'
@@ -34,10 +34,9 @@ export const ports = {
 export const Flags = S.Struct({ initialCount: S.Number })
 export type Flags = typeof Flags.Type
 
-export const init: Runtime.ElementInit<Model, Message, Flags> = flags => [
-  { count: flags.initialCount, step: 1 },
-  [],
-]
+export const init: Runtime.ElementInit<Model, Message, Flags> = flags => ({
+  model: { count: flags.initialCount, step: 1 },
+})
 
 // COMMAND
 
@@ -52,19 +51,22 @@ export const ReportCount = Command.define('ReportCount', {
 
 // UPDATE
 
-type UpdateReturn = readonly [Model, ReadonlyArray<Command.Command<Message>>]
+type UpdateReturn = Update.Return<Model, Message>
 
 const advance = (model: Model): UpdateReturn => {
   const count = model.count + model.step
-  return [evo(model, { count: () => count }), [ReportCount({ count })]]
+  return {
+    model: evo(model, { count: () => count }),
+    commands: [ReportCount({ count })],
+  }
 }
 
 export const update = (model: Model, message: Message) =>
   Message.match<UpdateReturn>(message, {
     Ticked: () => advance(model),
     ClickedAdvance: () => advance(model),
-    ChangedStep: ({ step }) => [evo(model, { step: () => step }), []],
-    CompletedReportCount: () => [model, []],
+    ChangedStep: ({ step }) => ({ model: evo(model, { step: () => step }) }),
+    CompletedReportCount: () => ({ model }),
   })
 
 // SUBSCRIPTION

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

@@ -7,7 +7,7 @@ import {
   Random,
   Schema as S,
 } from 'effect'
-import { Command, Runtime } from 'foldkit'
+import { Command, Runtime, type Update } from 'foldkit'
 import {
   Field,
   Invalid,
@@ -86,10 +86,9 @@ export const initialModel: Model = {
   submission: NotSubmitted(),
 }
 
-export const init: Runtime.ApplicationInit<Model, Message> = () => [
-  initialModel,
-  [],
-]
+export const init: Runtime.ApplicationInit<Model, Message> = () => ({
+  model: initialModel,
+})
 
 // FIELD VALIDATION
 
@@ -137,101 +136,92 @@ const isFormValid = (model: Model): boolean =>
 // UPDATE
 
 export const update = (model: Model, message: Message) =>
-  Message.match<readonly [Model, ReadonlyArray<Command.Command<Message>>]>(
-    message,
-    {
-      UpdatedName: ({ value }) => [
-        evo(model, {
-          name: () => validateName(value),
-        }),
-        [],
-      ],
+  Message.match<Update.Return<Model, Message>>(message, {
+    UpdatedName: ({ value }) => ({
+      model: evo(model, {
+        name: () => validateName(value),
+      }),
+    }),
 
-      UpdatedEmail: ({ value }) => {
-        const validateEmailResult = validateEmail(value)
+    UpdatedEmail: ({ value }) => {
+      const validateEmailResult = validateEmail(value)
 
-        if (validateEmailResult._tag === 'Valid') {
-          return [
-            evo(model, {
-              email: () => Validating({ value }),
-            }),
-            [ValidateEmail({ email: value })],
-          ]
-        } else {
-          return [
-            evo(model, {
-              email: () => validateEmailResult,
-            }),
-            [],
-          ]
+      if (validateEmailResult._tag === 'Valid') {
+        return {
+          model: evo(model, {
+            email: () => Validating({ value }),
+          }),
+          commands: [ValidateEmail({ email: value })],
+        }
+      } else {
+        return {
+          model: evo(model, {
+            email: () => validateEmailResult,
+          }),
         }
-      },
+      }
+    },
 
-      CompletedValidateEmail: ({ field }) => {
-        if (field.value === model.email.value) {
-          return [
-            evo(model, {
-              email: () => field,
-            }),
-            [],
-          ]
-        } else {
-          return [model, []]
+    CompletedValidateEmail: ({ field }) => {
+      if (field.value === model.email.value) {
+        return {
+          model: evo(model, {
+            email: () => field,
+          }),
         }
-      },
+      } else {
+        return { model }
+      }
+    },
 
-      UpdatedMessageText: ({ value }) => [
-        evo(model, {
-          messageText: () => Valid({ value }),
-        }),
-        [],
-      ],
+    UpdatedMessageText: ({ value }) => ({
+      model: evo(model, {
+        messageText: () => Valid({ value }),
+      }),
+    }),
 
-      ClickedFormSubmit: () => {
-        if (model.submission._tag === 'Submitting') {
-          return [model, []]
-        }
+    ClickedFormSubmit: () => {
+      if (model.submission._tag === 'Submitting') {
+        return { model }
+      }
 
-        if (!isFormValid(model)) {
-          return [model, []]
-        }
+      if (!isFormValid(model)) {
+        return { model }
+      }
 
-        return [
-          evo(model, {
-            submission: () => Submitting(),
-          }),
-          [
-            SubmitForm({
-              name: model.name.value,
-              email: model.email.value,
-              messageText: model.messageText.value,
-            }),
-          ],
-        ]
-      },
-
-      SucceededSubmitForm: ({ name }) => [
-        evo(model, {
-          submission: () =>
-            SubmitSuccess({
-              confirmationText: `Welcome to the waitlist, ${name}! We'll be in touch soon.`,
-            }),
+      return {
+        model: evo(model, {
+          submission: () => Submitting(),
         }),
-        [],
-      ],
-
-      FailedSubmitForm: () => [
-        evo(model, {
-          submission: () =>
-            SubmitError({
-              error:
-                'Sorry, there was an error adding you to the waitlist. Please try again.',
-            }),
-        }),
-        [],
-      ],
+        commands: [
+          SubmitForm({
+            name: model.name.value,
+            email: model.email.value,
+            messageText: model.messageText.value,
+          }),
+        ],
+      }
     },
-  )
+
+    SucceededSubmitForm: ({ name }) => ({
+      model: evo(model, {
+        submission: () =>
+          SubmitSuccess({
+            confirmationText: `Welcome to the waitlist, ${name}! We'll be in touch soon.`,
+          }),
+      }),
+    }),
+
+    FailedSubmitForm: () => ({
+      model: evo(model, {
+        submission: () =>
+          SubmitError({
+            error:
+              'Sorry, there was an error adding you to the waitlist. Please try again.',
+          }),
+      }),
+    }),
+  })
 
 // COMMAND
 

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

@@ -21,8 +21,8 @@ import { subscriptions } from './subscription'
 import { update } from './update'
 import { view } from './view'
 
-export const init: Runtime.ApplicationInit<Model, Message> = () => [
-  {
+export const init: Runtime.ApplicationInit<Model, Message> = () => ({
+  model: {
     particles: [],
     nextId: 0,
     elapsedSeconds: 0,
@@ -53,7 +53,9 @@ export const init: Runtime.ApplicationInit<Model, Message> = () => [
       step: NOISE_SCALE_STEP,
     }),
   },
-  Array.makeBy(INITIAL_PARTICLE_COUNT, () => GenerateAmbientParticle()),
-]
+  commands: Array.makeBy(INITIAL_PARTICLE_COUNT, () =>
+    GenerateAmbientParticle(),
+  ),
+})
 
 export { Message, Model, subscriptions, update, view }

package/dist/templates/examples/generative-art/src/update.ts

@@ -35,7 +35,7 @@ import { Message } from './message'
 import { Model, Particle, Point } from './model'
 import { fractalNoise } from './noise'
 
-type UpdateReturn = readonly [Model, ReadonlyArray<Command.Command<Message>>]
+type UpdateReturn = Update.Return<Model, Message>
 
 const computeFieldAngle = (
   point: Point,
@@ -215,13 +215,12 @@ const appendGeneratedParticle =
       initialAngle: generatedParticle.initialAngle,
       initialSpeedScale: generatedParticle.initialSpeedScale,
     }
-    return [
-      evo(model, {
+    return {
+      model: evo(model, {
         particles: Array.append(newParticle),
         nextId: Number.increment,
       }),
-      [],
-    ]
+    }
   }
 
 const foldFlowStrengthSliderOutMessage = M.type<Slider.OutMessage>().pipe(
@@ -229,7 +228,7 @@ const foldFlowStrengthSliderOutMessage = M.type<Slider.OutMessage>().pipe(
   M.tagsExhaustive({
     ChangedValue:
       ({ value }) =>
-      model => [evo(model, { flowStrength: () => value }), []],
+      model => ({ model: evo(model, { flowStrength: () => value }) }),
   }),
 )
 
@@ -247,7 +246,7 @@ const foldNoiseScaleSliderOutMessage = M.type<Slider.OutMessage>().pipe(
   M.tagsExhaustive({
     ChangedValue:
       ({ value }) =>
-      model => [evo(model, { noiseScale: () => value }), []],
+      model => ({ model: evo(model, { noiseScale: () => value }) }),
   }),
 )
 
@@ -279,37 +278,41 @@ export const update = (model: Model, message: Message) =>
         particles: () => advancedParticles,
         elapsedSeconds: () => nextElapsedSeconds,
       })
-      return [nextModel, spawnAmbientParticles(advancedParticles.length)]
+      return {
+        model: nextModel,
+        commands: spawnAmbientParticles(advancedParticles.length),
+      }
     },
 
     CompletedGenerateAmbientParticle: appendGeneratedParticle(model),
 
     CompletedGenerateBurstParticle: appendGeneratedParticle(model),
 
-    PressedCanvas: ({ x, y }) => [
+    PressedCanvas: ({ x, y }) => ({
       model,
-      spawnBurstParticles(x, y, computeBurstHueAnchor(model.elapsedSeconds)),
-    ],
+      commands: spawnBurstParticles(
+        x,
+        y,
+        computeBurstHueAnchor(model.elapsedSeconds),
+      ),
+    }),
 
-    MovedPointer: ({ x, y }) => [
-      evo(model, {
+    MovedPointer: ({ x, y }) => ({
+      model: evo(model, {
         maybeMousePosition: () => Option.some(Point.make({ x, y })),
       }),
-      [],
-    ],
+    }),
 
-    ClickedTogglePlay: () => [
-      evo(model, { isRunning: running => !running }),
-      [],
-    ],
+    ClickedTogglePlay: () => ({
+      model: evo(model, { isRunning: running => !running }),
+    }),
 
-    ClickedReset: () => [
-      evo(model, {
+    ClickedReset: () => ({
+      model: evo(model, {
         particles: () => [],
         maybeMousePosition: () => Option.none(),
       }),
-      [],
-    ],
+    }),
 
     GotFlowStrengthSliderMessage: ({ message }) =>
       foldFlowStrengthSlider(model, message),

package/dist/templates/examples/interrupting-commands/src/main.ts

@@ -9,7 +9,7 @@ import {
   Schema as S,
   pipe,
 } from 'effect'
-import { Command, Runtime } from 'foldkit'
+import { Command, Runtime, type Update } from 'foldkit'
 import { Document, Html, HtmlBuilder } from 'foldkit/html'
 import { defineMessageUnion } from 'foldkit/message'
 import { evo } from 'foldkit/struct'
@@ -56,10 +56,9 @@ export const initialModel: Model = {
   uploads: [],
 }
 
-export const init: Runtime.ApplicationInit<Model, Message> = () => [
-  initialModel,
-  [],
-]
+export const init: Runtime.ApplicationInit<Model, Message> = () => ({
+  model: initialModel,
+})
 
 // FAKE FILES
 
@@ -116,81 +115,84 @@ const setStatusForId = (uploadId: number, status: UploadStatus) =>
     upload.id === uploadId ? evo(upload, { status: () => status }) : upload,
   )
 
+type UpdateReturn = Update.Return<Model, Message>
+
 export const update = (model: Model, message: Message) =>
-  Message.match<readonly [Model, ReadonlyArray<Command.Command<Message>>]>(
-    message,
-    {
-      ClickedStartUpload: () => {
-        const fakeFile = fakeFileForUpload(model.uploadId)
-        const startedUpload = Upload.make({
-          id: model.uploadId,
-          fileName: fakeFile.name,
-          sizeMegabytes: fakeFile.sizeMegabytes,
-          status: 'Uploading',
-        })
-        return [
-          evo(model, {
-            uploadId: Number.increment,
-            uploads: Array.append(startedUpload),
+  Message.match<UpdateReturn>(message, {
+    ClickedStartUpload: () => {
+      const fakeFile = fakeFileForUpload(model.uploadId)
+      const startedUpload = Upload.make({
+        id: model.uploadId,
+        fileName: fakeFile.name,
+        sizeMegabytes: fakeFile.sizeMegabytes,
+        status: 'Uploading',
+      })
+      return {
+        model: evo(model, {
+          uploadId: Number.increment,
+          uploads: Array.append(startedUpload),
+        }),
+        commands: [
+          UploadFile({
+            uploadId: startedUpload.id,
+            sizeMegabytes: startedUpload.sizeMegabytes,
           }),
-          [
-            UploadFile({
-              uploadId: startedUpload.id,
-              sizeMegabytes: startedUpload.sizeMegabytes,
-            }),
-          ],
-        ]
-      },
+        ],
+      }
+    },
 
-      ClickedCancelUpload: ({ uploadId }) => [
-        model,
-        [CancelUploadFile({ uploadId })],
-      ],
+    ClickedCancelUpload: ({ uploadId }) => ({
+      model,
+      commands: [CancelUploadFile({ uploadId })],
+    }),
 
-      ClickedCancelAllUploads: () => [
+    ClickedCancelAllUploads: () => {
+      return {
         model,
-        pipe(
+        commands: pipe(
           model.uploads,
           Array.filter(upload => upload.status === 'Uploading'),
           Array.map(upload => CancelUploadFile({ uploadId: upload.id })),
         ),
-      ],
+      }
+    },
 
-      ClickedRestartUpload: ({ uploadId }) =>
-        pipe(
-          model.uploads,
-          Array.findFirst(
-            upload => upload.id === uploadId && upload.status === 'Cancelled',
-          ),
-          Option.match({
-            onNone: () => [model, []],
-            onSome: upload => [
-              evo(model, { uploads: setStatusForId(uploadId, 'Uploading') }),
-              [UploadFile({ uploadId, sizeMegabytes: upload.sizeMegabytes })],
+    ClickedRestartUpload: ({ uploadId }) =>
+      pipe(
+        model.uploads,
+        Array.findFirst(
+          upload => upload.id === uploadId && upload.status === 'Cancelled',
+        ),
+        Option.match({
+          onNone: () => ({ model }),
+          onSome: upload => ({
+            model: evo(model, {
+              uploads: setStatusForId(uploadId, 'Uploading'),
+            }),
+            commands: [
+              UploadFile({ uploadId, sizeMegabytes: upload.sizeMegabytes }),
             ],
           }),
-        ),
+        }),
+      ),
 
-      SucceededUploadFile: ({ uploadId }) => [
-        evo(model, { uploads: setStatusForId(uploadId, 'Done') }),
-        [],
-      ],
-
-      CompletedCancelUploadFile: ({ uploadId, outcome }) =>
-        M.value(outcome).pipe(
-          M.withReturnType<
-            readonly [Model, ReadonlyArray<Command.Command<Message>>]
-          >(),
-          M.tagsExhaustive({
-            Interrupted: () => [
-              evo(model, { uploads: setStatusForId(uploadId, 'Cancelled') }),
-              [],
-            ],
-            NotFound: () => [model, []],
+    SucceededUploadFile: ({ uploadId }) => ({
+      model: evo(model, { uploads: setStatusForId(uploadId, 'Done') }),
+    }),
+
+    CompletedCancelUploadFile: ({ uploadId, outcome }) =>
+      M.value(outcome).pipe(
+        M.withReturnType<UpdateReturn>(),
+        M.tagsExhaustive({
+          Interrupted: () => ({
+            model: evo(model, {
+              uploads: setStatusForId(uploadId, 'Cancelled'),
+            }),
           }),
-        ),
-    },
-  )
+          NotFound: () => ({ model }),
+        }),
+      ),
+  })
 
 // VIEW
 

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

@@ -48,8 +48,8 @@ export const init: Runtime.ApplicationInit<Model, Message, Flags> = ({
   initialWorkHistoryEntryId,
   initialEducationEntryId,
   initialSkillsEntryId,
-}) => [
-  {
+}) => ({
+  model: {
     currentStep: 'PersonalInfo',
     personalInfo: PersonalInfo.init(today),
     workHistory: WorkHistory.init(today, initialWorkHistoryEntryId),
@@ -63,7 +63,6 @@ export const init: Runtime.ApplicationInit<Model, Message, Flags> = ({
     stepTabs: Tabs.init({ id: 'step-tabs' }),
     isSubmitAttempted: false,
   },
-  [],
-]
+})
 
 export { Message, Model, update, view }

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

@@ -1,5 +1,5 @@
 import { Array, Match as M, Option, Schema as S, pipe } from 'effect'
-import { Command, File, Update } from 'foldkit'
+import { File, Update } from 'foldkit'
 import { defineMessageUnion } from 'foldkit/message'
 import { evo } from 'foldkit/struct'
 
@@ -37,15 +37,13 @@ export const init = (): Model => ({
 
 // UPDATE
 
-type UpdateReturn = readonly [Model, ReadonlyArray<Command.Command<Message>>]
-
 const foldResumeDropOutMessage = M.type<FileDrop.OutMessage>().pipe(
   M.withReturnType<Update.Step<Model, Message>>(),
   M.tagsExhaustive({
     ReceivedFiles:
       ({ files }) =>
-      model => [
-        evo(model, {
+      model => ({
+        model: evo(model, {
           maybeResume: () =>
             pipe(
               files,
@@ -53,9 +51,8 @@ const foldResumeDropOutMessage = M.type<FileDrop.OutMessage>().pipe(
               Option.orElse(() => model.maybeResume),
             ),
         }),
-        [],
-      ],
-    RejectedNonFiles: () => model => [model, []],
+      }),
+    RejectedNonFiles: () => model => ({ model }),
   }),
 )
 
@@ -73,13 +70,12 @@ const foldAdditionalFilesDropOutMessage = M.type<FileDrop.OutMessage>().pipe(
   M.tagsExhaustive({
     ReceivedFiles:
       ({ files }) =>
-      model => [
-        evo(model, {
+      model => ({
+        model: evo(model, {
           additionalFiles: Array.appendAll(files),
         }),
-        [],
-      ],
-    RejectedNonFiles: () => model => [model, []],
+      }),
+    RejectedNonFiles: () => model => ({ model }),
   }),
 )
 
@@ -94,18 +90,19 @@ const foldAdditionalFilesDrop = Update.foldChild({
 })
 
 export const update = (model: Model, message: Message) =>
-  Message.match<UpdateReturn>(message, {
+  Message.match<Update.Return<Model, Message>>(message, {
     GotResumeDropMessage: ({ message }) => foldResumeDrop(model, message),
 
     GotAdditionalFilesDropMessage: ({ message }) =>
       foldAdditionalFilesDrop(model, message),
 
-    RemovedResume: () => [evo(model, { maybeResume: () => Option.none() }), []],
+    RemovedResume: () => ({
+      model: evo(model, { maybeResume: () => Option.none() }),
+    }),
 
-    RemovedAdditionalFile: ({ fileIndex }) => [
-      evo(model, {
+    RemovedAdditionalFile: ({ fileIndex }) => ({
+      model: evo(model, {
         additionalFiles: Array.remove(fileIndex),
       }),
-      [],
-    ],
+    }),
   })

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

@@ -1,5 +1,5 @@
 import { Schema as S } from 'effect'
-import { Command } from 'foldkit'
+import { type Update } from 'foldkit'
 import { defineMessageUnion } from 'foldkit/message'
 import { evo } from 'foldkit/struct'
 
@@ -26,9 +26,9 @@ export const init = (): Model => ({
 
 // UPDATE
 
-type UpdateReturn = readonly [Model, ReadonlyArray<Command.Command<Message>>]
-
 export const update = (model: Model, message: Message) =>
-  Message.match<UpdateReturn>(message, {
-    UpdatedContent: ({ value }) => [evo(model, { content: () => value }), []],
+  Message.match<Update.Return<Model, Message>>(message, {
+    UpdatedContent: ({ value }) => ({
+      model: evo(model, { content: () => value }),
+    }),
   })