create-foldkit-app 0.32.1 → 0.33.0

package/dist/templates/examples/job-application/src/step/workHistory/story.test.ts

@@ -0,0 +1,87 @@
+import { Array, Option, pipe } from 'effect'
+import { Calendar } from 'foldkit'
+import { Command, given, message, model, story } from 'foldkit/story'
+import { describe, expect, test } from 'vitest'
+
+import * as Entry from './entry'
+import { GenerateEntryId, Message, init, update } from './workHistory'
+
+const today = Calendar.make(2026, 4, 16)
+const givenInitial = given(init(today, 'work-history-entry-1'))
+
+describe('workHistory', () => {
+  test('ClickedAddEntry generates an id and appends an entry', () => {
+    story(
+      update,
+      givenInitial,
+      message(Message.ClickedAddEntry()),
+      Command.expectHas(GenerateEntryId),
+      Command.resolve(
+        GenerateEntryId,
+        Message.SucceededGenerateEntryId({ entryId: 'test-work-1' }),
+      ),
+      model(model => {
+        expect(model.entries).toHaveLength(2)
+      }),
+    )
+  })
+
+  test('FailedGenerateEntryId leaves the entries unchanged', () => {
+    story(
+      update,
+      givenInitial,
+      message(Message.FailedGenerateEntryId()),
+      Command.expectNone(),
+      model(model => {
+        expect(model).toEqual(init(today, 'work-history-entry-1'))
+      }),
+    )
+  })
+
+  test('an entry OutMessage.Removed removes that entry', () => {
+    const firstEntry = Option.getOrThrow(
+      Array.head(init(today, 'work-history-entry-1').entries),
+    )
+
+    story(
+      update,
+      givenInitial,
+      message(
+        Message.GotEntryMessage({
+          entryId: firstEntry.id,
+          message: Entry.Message.ClickedRemoveSelf(),
+        }),
+      ),
+      model(model => {
+        expect(model.entries).toHaveLength(0)
+      }),
+    )
+  })
+
+  test('GotEntryMessage folds a company update into the matching entry', () => {
+    const firstEntry = Option.getOrThrow(
+      Array.head(init(today, 'work-history-entry-1').entries),
+    )
+
+    story(
+      update,
+      givenInitial,
+      message(
+        Message.GotEntryMessage({
+          entryId: firstEntry.id,
+          message: Entry.Message.UpdatedCompany({ value: 'Foldkit Inc.' }),
+        }),
+      ),
+      model(model => {
+        expect(
+          pipe(
+            model.entries,
+            Array.head,
+            Option.map(entry => entry.company.value),
+            Option.getOrThrow,
+          ),
+        ).toBe('Foldkit Inc.')
+      }),
+    )
+  })
+})

package/dist/templates/examples/job-application/src/{view/workHistory.ts → step/workHistory/view.ts}

@@ -3,14 +3,10 @@ import type { Html } from 'foldkit/html'
 
 import { Button } from '@foldkit/ui'
 
-import { WorkHistory } from '../step'
-import { Message } from '../step/workHistory'
-import { workEntryView } from './workEntry'
+import * as Entry from './entry'
+import { Message, type Model } from './workHistory'
 
-export const workHistoryView = Submodel.defineView<
-  WorkHistory.Model,
-  WorkHistory.Message
->((model, h): Html =>
+export const view = Submodel.defineView<Model, Message>((model, h): Html =>
   h.div(
     [h.Class('space-y-6')],
     [
@@ -24,7 +20,7 @@ export const workHistoryView = Submodel.defineView<
           h.submodel({
             slotId: entry.id,
             model: entry,
-            view: workEntryView,
+            view: Entry.view,
             toParentMessage: message =>
               Message.GotEntryMessage({
                 entryId: entry.id,

package/dist/templates/examples/job-application/src/story.test.ts

@@ -1,17 +1,14 @@
 import { Array, Option, pipe } from 'effect'
-import { Calendar } from 'foldkit'
-import { Valid, Validating } from 'foldkit/fieldValidation'
+import { Validating } from 'foldkit/fieldValidation'
 import { Command, given, message, model, story } from 'foldkit/story'
 import { describe, expect, test } from 'vitest'
 
-import { Menu, Tabs } from '@foldkit/ui'
-import { Message as FileDropMessage } from '@foldkit/ui/fileDrop'
-import { Message as MenuMessage } from '@foldkit/ui/menu'
-import { Message as TabsMessage } from '@foldkit/ui/tabs'
+import { FileDrop, Menu, Tabs } from '@foldkit/ui'
 
 import { SubmitApplication } from './command'
+import { completeModel, initialModel } from './main.fixture'
 import { Message } from './message'
-import { type Model, Submission } from './model'
+import { Submission } from './model'
 import {
   Attachments,
   CoverLetter,
@@ -20,75 +17,18 @@ import {
   Skills,
   WorkHistory,
 } from './step'
-import { Message as AttachmentsMessage } from './step/attachments'
-import { Message as CoverLetterMessage } from './step/coverLetter'
-import { Message as EducationMessage } from './step/education'
-import { Message as PersonalInfoMessage } from './step/personalInfo'
-import { Message as SkillsMessage } from './step/skills'
-import { Message as WorkHistoryMessage } from './step/workHistory'
 import { update } from './update'
 
-const today = Calendar.make(2026, 4, 16)
-
-const initialModel: Model = {
-  currentStep: 'PersonalInfo',
-  personalInfo: PersonalInfo.init(today),
-  workHistory: WorkHistory.init(today, 'work-history-entry-1'),
-  education: Education.init(today, 'education-entry-1'),
-  skills: Skills.init('skills-entry-1'),
-  coverLetter: CoverLetter.init(),
-  attachments: Attachments.init(),
-  isPreviewVisible: false,
-  submission: Submission.NotSubmitted(),
-  stepMenu: Menu.init({ id: 'step-menu' }),
-  stepTabs: Tabs.init({ id: 'step-tabs' }),
-  isSubmitAttempted: false,
-}
-
-const completeModel: Model = {
-  ...initialModel,
-  personalInfo: {
-    ...initialModel.personalInfo,
-    firstName: Valid({ value: 'Jane' }),
-    lastName: Valid({ value: 'Doe' }),
-    email: Valid({ value: 'jane@example.com' }),
-  },
-  workHistory: {
-    ...initialModel.workHistory,
-    entries: initialModel.workHistory.entries.map(entry => ({
-      ...entry,
-      company: Valid({ value: 'Foldkit' }),
-      title: Valid({ value: 'Engineer' }),
-    })),
-  },
-  education: {
-    ...initialModel.education,
-    entries: initialModel.education.entries.map(entry => ({
-      ...entry,
-      school: Valid({ value: 'MIT' }),
-      degree: Valid({ value: 'BS' }),
-      fieldOfStudy: Valid({ value: 'CS' }),
-    })),
-  },
-  skills: {
-    ...initialModel.skills,
-    entries: initialModel.skills.entries.map(entry => ({
-      ...entry,
-      name: Valid({ value: 'TypeScript' }),
-    })),
-  },
-}
-
 const givenInitial = given(initialModel)
 
 const resolveFocusTab = Command.resolve(
   Tabs.FocusTab,
-  TabsMessage.CompletedFocusTab(),
+  Tabs.Message.CompletedFocusTab(),
 )
 
 const resolveFocusMenuButton = Command.resolve(
   Menu.FocusButton,
-  MenuMessage.CompletedFocusButton(),
+  Menu.Message.CompletedFocusButton(),
 )
 
 describe('update', () => {
@@ -155,7 +95,7 @@ describe('update', () => {
         givenInitial,
         message(
           Message.GotStepTabsMessage({
-            message: TabsMessage.SelectedTab({ index: 6, value: 'Review' }),
+            message: Tabs.Message.SelectedTab({ index: 6, value: 'Review' }),
           }),
         ),
         model(model => {
@@ -171,15 +111,15 @@ describe('update', () => {
         givenInitial,
         message(
           Message.GotStepMenuMessage({
-            message: MenuMessage.Opened({
+            message: Menu.Message.Opened({
               maybeActiveItemIndex: Option.none(),
             }),
           }),
         ),
-        Command.resolve(Menu.FocusItems, MenuMessage.CompletedFocusItems()),
+        Command.resolve(Menu.FocusItems, Menu.Message.CompletedFocusItems()),
         message(
           Message.GotStepMenuMessage({
-            message: MenuMessage.SelectedItem({
+            message: Menu.Message.SelectedItem({
               index: 5,
               item: 'Attachments',
             }),
@@ -210,390 +150,80 @@ describe('update', () => {
     })
   })
 
-  describe('personal info delegation', () => {
-    test('first name update is delegated to personal info step', () => {
+  describe('child folding', () => {
+    test('GotPersonalInfoMessage writes through to personalInfo', () => {
       story(
         update,
         givenInitial,
         message(
           Message.GotPersonalInfoMessage({
-            message: PersonalInfoMessage.UpdatedFirstName({ value: 'Jane' }),
+            message: PersonalInfo.Message.UpdatedFirstName({ value: 'Jane' }),
           }),
         ),
         model(model => {
           expect(model.personalInfo.firstName.value).toBe('Jane')
-          expect(model.personalInfo.firstName._tag).toBe('Valid')
         }),
       )
     })
 
-    test('short first name produces validation error', () => {
-      story(
-        update,
-        givenInitial,
-        message(
-          Message.GotPersonalInfoMessage({
-            message: PersonalInfoMessage.UpdatedFirstName({ value: 'J' }),
-          }),
-        ),
-        model(model => {
-          expect(model.personalInfo.firstName._tag).toBe('Invalid')
-        }),
-      )
-    })
-
-    test('email triggers async validation after passing sync checks', () => {
-      story(
-        update,
-        givenInitial,
-        message(
-          Message.GotPersonalInfoMessage({
-            message: PersonalInfoMessage.UpdatedEmail({
-              value: 'jane@example.com',
-            }),
-          }),
-        ),
-        Command.expectHas(PersonalInfo.ValidateEmailAsync),
-        Command.resolve(
-          PersonalInfo.ValidateEmailAsync,
-          PersonalInfoMessage.CompletedValidateEmailAsync({
-            validationId: 1,
-            field: Valid({ value: 'jane@example.com' }),
-          }),
-        ),
-        model(model => {
-          expect(model.personalInfo.email._tag).toBe('Valid')
-        }),
-      )
-    })
-
-    test('malformed email fails sync validation without async command', () => {
-      story(
-        update,
-        givenInitial,
-        message(
-          Message.GotPersonalInfoMessage({
-            message: PersonalInfoMessage.UpdatedEmail({ value: 'not-email' }),
-          }),
-        ),
-        Command.expectNone(),
-        model(model => {
-          expect(model.personalInfo.email._tag).toBe('Invalid')
-        }),
-      )
-    })
-
-    test('stale email async result is discarded', () => {
-      const modelWithInFlightValidation: Model = {
-        ...initialModel,
-        personalInfo: {
-          ...initialModel.personalInfo,
-          email: Validating({ value: 'jane@example.com' }),
-          emailValidationId: 5,
-        },
-      }
-
-      story(
-        update,
-        given(modelWithInFlightValidation),
-        message(
-          Message.GotPersonalInfoMessage({
-            message: PersonalInfoMessage.CompletedValidateEmailAsync({
-              validationId: 3,
-              field: Valid({ value: 'old@example.com' }),
-            }),
-          }),
-        ),
-        model(model => {
-          expect(model.personalInfo.email._tag).toBe('Validating')
-          expect(model.personalInfo.email.value).toBe('jane@example.com')
-          expect(model.personalInfo.emailValidationId).toBe(5)
-        }),
-      )
-    })
-  })
-
-  describe('work history delegation', () => {
-    test('adds a new work entry', () => {
+    test('GotWorkHistoryMessage writes through to workHistory', () => {
       story(
         update,
         givenInitial,
         message(
           Message.GotWorkHistoryMessage({
-            message: WorkHistoryMessage.SucceededGenerateEntryId({
+            message: WorkHistory.Message.SucceededGenerateEntryId({
               entryId: 'test-work-1',
             }),
           }),
         ),
         model(model => {
-          expect(model.workHistory.entries.length).toBe(2)
-        }),
-      )
-    })
-
-    test('keeps work history unchanged when entry ID generation fails', () => {
-      story(
-        update,
-        givenInitial,
-        message(
-          Message.GotWorkHistoryMessage({
-            message: WorkHistoryMessage.FailedGenerateEntryId(),
-          }),
-        ),
-        Command.expectNone(),
-        model(model => {
-          expect(model.workHistory).toEqual(initialModel.workHistory)
-        }),
-      )
-    })
-
-    test('removes a work entry', () => {
-      const firstEntry = Option.getOrThrow(
-        Array.head(initialModel.workHistory.entries),
-      )
-
-      story(
-        update,
-        givenInitial,
-        message(
-          Message.GotWorkHistoryMessage({
-            message: WorkHistoryMessage.RemovedEntry({
-              entryId: firstEntry.id,
-            }),
-          }),
-        ),
-        model(model => {
-          expect(model.workHistory.entries.length).toBe(0)
-        }),
-      )
-    })
-
-    test('updates company in a work entry', () => {
-      const firstEntry = Option.getOrThrow(
-        Array.head(initialModel.workHistory.entries),
-      )
-
-      story(
-        update,
-        givenInitial,
-        message(
-          Message.GotWorkHistoryMessage({
-            message: WorkHistoryMessage.GotEntryMessage({
-              entryId: firstEntry.id,
-              message: WorkHistory.Entry.Message.UpdatedCompany({
-                value: 'Foldkit Inc.',
-              }),
-            }),
-          }),
-        ),
-        model(model => {
-          expect(
-            pipe(
-              model.workHistory.entries,
-              Array.head,
-              Option.map(entry => entry.company.value),
-              Option.getOrThrow,
-            ),
-          ).toBe('Foldkit Inc.')
+          expect(model.workHistory.entries).toHaveLength(2)
         }),
       )
     })
-  })
 
-  describe('education delegation', () => {
-    test('adds a new education entry', () => {
+    test('GotEducationMessage writes through to education', () => {
       story(
         update,
         givenInitial,
         message(
           Message.GotEducationMessage({
-            message: EducationMessage.SucceededGenerateEntryId({
+            message: Education.Message.SucceededGenerateEntryId({
               entryId: 'test-edu-1',
             }),
           }),
         ),
         model(model => {
-          expect(model.education.entries.length).toBe(2)
+          expect(model.education.entries).toHaveLength(2)
         }),
       )
     })
 
-    test('keeps education unchanged when entry ID generation fails', () => {
-      story(
-        update,
-        givenInitial,
-        message(
-          Message.GotEducationMessage({
-            message: EducationMessage.FailedGenerateEntryId(),
-          }),
-        ),
-        Command.expectNone(),
-        model(model => {
-          expect(model.education).toEqual(initialModel.education)
-        }),
-      )
-    })
-
-    test('removes an education entry', () => {
-      const firstEntry = Option.getOrThrow(
-        Array.head(initialModel.education.entries),
-      )
-
-      story(
-        update,
-        givenInitial,
-        message(
-          Message.GotEducationMessage({
-            message: EducationMessage.RemovedEntry({ entryId: firstEntry.id }),
-          }),
-        ),
-        model(model => {
-          expect(model.education.entries.length).toBe(0)
-        }),
-      )
-    })
-
-    test('updates school in an education entry', () => {
-      const firstEntry = Option.getOrThrow(
-        Array.head(initialModel.education.entries),
-      )
-
-      story(
-        update,
-        givenInitial,
-        message(
-          Message.GotEducationMessage({
-            message: EducationMessage.GotEntryMessage({
-              entryId: firstEntry.id,
-              message: Education.Entry.Message.UpdatedSchool({ value: 'MIT' }),
-            }),
-          }),
-        ),
-        model(model => {
-          expect(
-            pipe(
-              model.education.entries,
-              Array.head,
-              Option.map(entry => entry.school.value),
-              Option.getOrThrow,
-            ),
-          ).toBe('MIT')
-        }),
-      )
-    })
-
-    test('empty school is Invalid with required message', () => {
-      const firstEntry = Option.getOrThrow(
-        Array.head(initialModel.education.entries),
-      )
-
-      story(
-        update,
-        givenInitial,
-        message(
-          Message.GotEducationMessage({
-            message: EducationMessage.GotEntryMessage({
-              entryId: firstEntry.id,
-              message: Education.Entry.Message.UpdatedSchool({ value: 'MIT' }),
-            }),
-          }),
-        ),
-        message(
-          Message.GotEducationMessage({
-            message: EducationMessage.GotEntryMessage({
-              entryId: firstEntry.id,
-              message: Education.Entry.Message.UpdatedSchool({ value: '' }),
-            }),
-          }),
-        ),
-        model(model => {
-          expect(
-            pipe(
-              model.education.entries,
-              Array.head,
-              Option.map(entry => entry.school._tag),
-              Option.getOrThrow,
-            ),
-          ).toBe('Invalid')
-        }),
-      )
-    })
-  })
-
-  describe('skills delegation', () => {
-    test('adds a new skill entry', () => {
+    test('GotSkillsMessage writes through to skills', () => {
       story(
         update,
         givenInitial,
         message(
           Message.GotSkillsMessage({
-            message: SkillsMessage.SucceededGenerateEntryId({
+            message: Skills.Message.SucceededGenerateEntryId({
               entryId: 'test-skill-1',
             }),
           }),
         ),
         model(model => {
-          expect(model.skills.entries.length).toBe(2)
-        }),
-      )
-    })
-
-    test('keeps skills unchanged when entry ID generation fails', () => {
-      story(
-        update,
-        givenInitial,
-        message(
-          Message.GotSkillsMessage({
-            message: SkillsMessage.FailedGenerateEntryId(),
-          }),
-        ),
-        Command.expectNone(),
-        model(model => {
-          expect(model.skills).toEqual(initialModel.skills)
-        }),
-      )
-    })
-
-    test('updates skill name', () => {
-      const firstEntry = Option.getOrThrow(
-        Array.head(initialModel.skills.entries),
-      )
-
-      story(
-        update,
-        givenInitial,
-        message(
-          Message.GotSkillsMessage({
-            message: SkillsMessage.GotEntryMessage({
-              entryId: firstEntry.id,
-              message: Skills.Entry.Message.UpdatedName({
-                value: 'TypeScript',
-              }),
-            }),
-          }),
-        ),
-        model(model => {
-          expect(
-            pipe(
-              model.skills.entries,
-              Array.head,
-              Option.map(entry => entry.name.value),
-              Option.getOrThrow,
-            ),
-          ).toBe('TypeScript')
+          expect(model.skills.entries).toHaveLength(2)
         }),
       )
     })
-  })
 
-  describe('cover letter delegation', () => {
-    test('updates content', () => {
+    test('GotCoverLetterMessage writes through to coverLetter', () => {
       story(
         update,
         givenInitial,
         message(
           Message.GotCoverLetterMessage({
-            message: CoverLetterMessage.UpdatedContent({
+            message: CoverLetter.Message.UpdatedContent({
               value: 'I love the Elm Architecture.',
             }),
           }),
@@ -603,45 +233,24 @@ describe('update', () => {
         }),
       )
     })
-  })
 
-  describe('attachments delegation', () => {
-    test('stores a dropped resume as the maybeResume File', () => {
+    test('GotAttachmentsMessage writes through to attachments', () => {
       const resume = new globalThis.File(['pdf-bytes'], 'resume.pdf', {
         type: 'application/pdf',
       })
-      story(
-        update,
-        givenInitial,
-        message(
-          Message.GotAttachmentsMessage({
-            message: AttachmentsMessage.GotResumeDropMessage({
-              message: FileDropMessage.DroppedFiles({ files: [resume] }),
-            }),
-          }),
-        ),
-        model(model => {
-          expect(model.attachments.maybeResume._tag).toBe('Some')
-        }),
-      )
-    })
 
-    test('appends dropped additional files to the list', () => {
-      const file = new globalThis.File(['content'], 'portfolio.pdf', {
-        type: 'application/pdf',
-      })
       story(
         update,
         givenInitial,
         message(
           Message.GotAttachmentsMessage({
-            message: AttachmentsMessage.GotAdditionalFilesDropMessage({
-              message: FileDropMessage.DroppedFiles({ files: [file] }),
+            message: Attachments.Message.GotResumeDropMessage({
+              message: FileDrop.Message.DroppedFiles({ files: [resume] }),
             }),
           }),
         ),
         model(model => {
-          expect(model.attachments.additionalFiles).toHaveLength(1)
+          expect(model.attachments.maybeResume._tag).toBe('Some')
         }),
       )
     })