create-foldkit-app 0.32.0 → 0.32.1

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

@@ -1,12 +1,4 @@
-import {
-  Array,
-  Duration,
-  Effect,
-  Match as M,
-  Number,
-  Option,
-  Schema as S,
-} from 'effect'
+import { Array, Duration, Effect, Match, Number, Option, Schema } from 'effect'
 import { Command, Update } from 'foldkit'
 import { CalendarDate } from 'foldkit/calendar'
 import {
@@ -32,35 +24,35 @@ import { revealFieldErrors } from './validation'
 
 const PronounsListbox = Listbox.create<string>()
 
-export const Model = S.Struct({
-  firstName: Field(S.String),
-  lastName: Field(S.String),
-  email: Field(S.String),
-  emailValidationId: S.Number,
-  phone: Field(S.String),
+export const Model = Schema.Struct({
+  firstName: Field(Schema.String),
+  lastName: Field(Schema.String),
+  email: Field(Schema.String),
+  emailValidationId: Schema.Number,
+  phone: Field(Schema.String),
   pronouns: Listbox.Model,
-  maybeSelectedPronoun: S.Option(S.String),
-  customPronouns: S.String,
-  portfolioUrl: Field(S.String),
+  maybeSelectedPronoun: Schema.Option(Schema.String),
+  customPronouns: Schema.String,
+  portfolioUrl: Field(Schema.String),
   availableDate: DatePicker.Model,
-  maybeAvailableDate: S.Option(CalendarDate),
+  maybeAvailableDate: Schema.Option(CalendarDate),
 })
 export type Model = typeof Model.Type
 
 // MESSAGE
 
 export const Message = defineMessageUnion({
-  UpdatedFirstName: { value: S.String },
-  UpdatedLastName: { value: S.String },
-  UpdatedEmail: { value: S.String },
+  UpdatedFirstName: { value: Schema.String },
+  UpdatedLastName: { value: Schema.String },
+  UpdatedEmail: { value: Schema.String },
   CompletedValidateEmailAsync: {
-    validationId: S.Number,
-    field: Field(S.String),
+    validationId: Schema.Number,
+    field: Field(Schema.String),
   },
-  UpdatedPhone: { value: S.String },
+  UpdatedPhone: { value: Schema.String },
   GotPronounsMessage: { message: Listbox.Message },
-  UpdatedCustomPronouns: { value: S.String },
-  UpdatedPortfolioUrl: { value: S.String },
+  UpdatedCustomPronouns: { value: Schema.String },
+  UpdatedPortfolioUrl: { value: Schema.String },
   GotAvailableDateMessage: { message: DatePicker.Message },
 })
 
@@ -140,7 +132,7 @@ const isEmailTaken = (emailInput: string): Effect.Effect<boolean> =>
   })
 
 export const ValidateEmailAsync = Command.define('ValidateEmailAsync', {
-  args: { emailInput: S.String, validationId: S.Number },
+  args: { emailInput: Schema.String, validationId: Schema.Number },
   messages: [Message.CompletedValidateEmailAsync],
   execute: ({ emailInput, validationId }) =>
     Effect.gen(function* () {
@@ -164,16 +156,15 @@ export const ValidateEmailAsync = Command.define('ValidateEmailAsync', {
 
 type UpdateReturn = Update.Return<Model, Message>
 
-const foldPronounsOutMessage = M.type<Listbox.OutMessage>().pipe(
-  M.withReturnType<Update.Step<Model, Message>>(),
-  M.tagsExhaustive({
-    Selected:
-      ({ value }) =>
-      model => ({
-        model: evo(model, { maybeSelectedPronoun: () => Option.some(value) }),
-      }),
-  }),
-)
+const foldPronounsOutMessage = Listbox.OutMessage.match<
+  Update.Step<Model, Message>
+>({
+  Selected:
+    ({ value }) =>
+    model => ({
+      model: evo(model, { maybeSelectedPronoun: () => Option.some(value) }),
+    }),
+})
 
 const foldPronouns = Update.foldChild({
   update: PronounsListbox.update,
@@ -183,20 +174,19 @@ const foldPronouns = Update.foldChild({
   foldOutMessage: foldPronounsOutMessage,
 })
 
-const foldAvailableDateOutMessage = M.type<DatePicker.OutMessage>().pipe(
-  M.withReturnType<Update.Step<Model, Message>>(),
-  M.tagsExhaustive({
-    SelectedDate:
-      ({ date }) =>
-      model => ({
-        model: evo(model, { maybeAvailableDate: () => Option.some(date) }),
-      }),
-    ClearedDate: () => model => ({
-      model: evo(model, { maybeAvailableDate: () => Option.none() }),
+const foldAvailableDateOutMessage = DatePicker.OutMessage.match<
+  Update.Step<Model, Message>
+>({
+  SelectedDate:
+    ({ date }) =>
+    model => ({
+      model: evo(model, { maybeAvailableDate: () => Option.some(date) }),
     }),
-    ChangedViewMonth: () => model => ({ model }),
+  ClearedDate: () => model => ({
+    model: evo(model, { maybeAvailableDate: () => Option.none() }),
   }),
-)
+  ChangedViewMonth: () => model => ({ model }),
+})
 
 const foldAvailableDate = Update.foldChild({
   update: DatePicker.update,
@@ -219,16 +209,16 @@ export const update = (model: Model, message: Message) =>
 
     UpdatedEmail: ({ value }) => {
       const validationId = Number.increment(model.emailValidationId)
-      return M.value(validateEmail(value)).pipe(
-        M.withReturnType<UpdateReturn>(),
-        M.tag('Valid', () => ({
+      return Match.value(validateEmail(value)).pipe(
+        Match.withReturnType<UpdateReturn>(),
+        Match.tag('Valid', () => ({
           model: evo(model, {
             email: () => Validating({ value }),
             emailValidationId: () => validationId,
           }),
           commands: [ValidateEmailAsync({ emailInput: value, validationId })],
         })),
-        M.orElse(syncResult => ({
+        Match.orElse(syncResult => ({
           model: evo(model, {
             email: () => syncResult,
             emailValidationId: () => validationId,

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

@@ -1,4 +1,4 @@
-import { Match as M, Option, Schema as S } from 'effect'
+import { Option, Schema } from 'effect'
 import { Update } from 'foldkit'
 import {
   Field,
@@ -32,9 +32,9 @@ export const proficiencyRadioGroupId = (entryId: string): string =>
 export const ProficiencyRadioGroup =
   RadioGroup.create<ProficiencyLevel.ProficiencyLevel>()
 
-export const Model = S.Struct({
-  id: S.String,
-  name: Field(S.String),
+export const Model = Schema.Struct({
+  id: Schema.String,
+  name: Field(Schema.String),
   proficiency: ProficiencyLevel.ProficiencyLevel,
   proficiencyRadioGroup: RadioGroup.Model,
 })
@@ -43,7 +43,7 @@ export type Model = typeof Model.Type
 // MESSAGE
 
 export const Message = defineMessageUnion({
-  UpdatedName: { value: S.String },
+  UpdatedName: { value: Schema.String },
   GotProficiencyRadioGroupMessage: { message: RadioGroup.Message },
   ClickedRemoveSelf: {},
 })
@@ -73,16 +73,14 @@ export const init = (entryId: string): Model => ({
 
 // UPDATE
 
-const foldProficiencyRadioGroupOutMessage = M.type<
+const foldProficiencyRadioGroupOutMessage = RadioGroup.OutMessage.match<
+  Update.Step<Model, Message>,
   RadioGroup.OutMessage<ProficiencyLevel.ProficiencyLevel>
->().pipe(
-  M.withReturnType<Update.Step<Model, Message>>(),
-  M.tagsExhaustive({
-    Selected:
-      ({ value }) =>
-      model => ({ model: evo(model, { proficiency: () => value }) }),
-  }),
-)
+>({
+  Selected:
+    ({ value }) =>
+    model => ({ model: evo(model, { proficiency: () => value }) }),
+})
 
 const foldProficiencyRadioGroup = Update.foldChild({
   update: ProficiencyRadioGroup.update,

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

@@ -1,4 +1,4 @@
-import { Array, Crypto, Effect, Match as M, Schema as S } from 'effect'
+import { Array, Crypto, Effect, Schema } from 'effect'
 import { Command, Update } from 'foldkit'
 import { defineMessageUnion } from 'foldkit/message'
 import { evo } from 'foldkit/struct'
@@ -9,8 +9,8 @@ import * as Entry from './entry'
 
 // MODEL
 
-export const Model = S.Struct({
-  entries: S.Array(Entry.Model),
+export const Model = Schema.Struct({
+  entries: Schema.Array(Entry.Model),
 })
 export type Model = typeof Model.Type
 
@@ -18,11 +18,11 @@ export type Model = typeof Model.Type
 
 export const Message = defineMessageUnion({
   ClickedAddEntry: {},
-  SucceededGenerateEntryId: { entryId: S.String },
+  SucceededGenerateEntryId: { entryId: Schema.String },
   FailedGenerateEntryId: {},
-  RemovedEntry: { entryId: S.String },
+  RemovedEntry: { entryId: Schema.String },
   GotEntryMessage: {
-    entryId: S.String,
+    entryId: Schema.String,
     message: Entry.Message,
   },
 })
@@ -54,16 +54,13 @@ export const GenerateEntryId = Command.define('GenerateEntryId', {
 const foldEntryOutMessage: (
   entryId: string,
 ) => (outMessage: Entry.OutMessage) => Update.Step<Model, Message> = entryId =>
-  M.type<Entry.OutMessage>().pipe(
-    M.withReturnType<Update.Step<Model, Message>>(),
-    M.tagsExhaustive({
-      Removed: () => model => ({
-        model: evo(model, {
-          entries: Array.filter(entry => entry.id !== entryId),
-        }),
+  Entry.OutMessage.match<Update.Step<Model, Message>>({
+    Removed: () => model => ({
+      model: evo(model, {
+        entries: Array.filter(entry => entry.id !== entryId),
       }),
     }),
-  )
+  })
 
 const foldEntry = (entryId: string) =>
   Update.foldChild({

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

@@ -1,4 +1,4 @@
-import { Match as M, Option, Schema as S } from 'effect'
+import { Option, Schema } from 'effect'
 import { Update } from 'foldkit'
 import { CalendarDate } from 'foldkit/calendar'
 import {
@@ -31,28 +31,28 @@ const validateTitle = validate(titleRules)
 
 // MODEL
 
-export const Model = S.Struct({
-  id: S.String,
-  company: Field(S.String),
-  title: Field(S.String),
+export const Model = Schema.Struct({
+  id: Schema.String,
+  company: Field(Schema.String),
+  title: Field(Schema.String),
   startDate: DatePicker.Model,
-  maybeStartDate: S.Option(CalendarDate),
+  maybeStartDate: Schema.Option(CalendarDate),
   endDate: DatePicker.Model,
-  maybeEndDate: S.Option(CalendarDate),
-  isCurrentlyEmployed: S.Boolean,
-  description: S.String,
+  maybeEndDate: Schema.Option(CalendarDate),
+  isCurrentlyEmployed: Schema.Boolean,
+  description: Schema.String,
 })
 export type Model = typeof Model.Type
 
 // MESSAGE
 
 export const Message = defineMessageUnion({
-  UpdatedCompany: { value: S.String },
-  UpdatedTitle: { value: S.String },
+  UpdatedCompany: { value: Schema.String },
+  UpdatedTitle: { value: Schema.String },
   GotStartDateMessage: { message: DatePicker.Message },
   GotEndDateMessage: { message: DatePicker.Message },
-  ToggledCurrentlyEmployed: { isChecked: S.Boolean },
-  UpdatedDescription: { value: S.String },
+  ToggledCurrentlyEmployed: { isChecked: Schema.Boolean },
+  UpdatedDescription: { value: Schema.String },
   ClickedRemoveSelf: {},
 })
 
@@ -84,26 +84,25 @@ export const init = (entryId: string, today: CalendarDate): Model => ({
 
 // UPDATE
 
-const foldStartDateOutMessage = M.type<DatePicker.OutMessage>().pipe(
-  M.withReturnType<Update.Step<Model, Message>>(),
-  M.tagsExhaustive({
-    ChangedViewMonth: () => model => ({ model }),
-    SelectedDate:
-      ({ date }) =>
-      model => ({
-        model: evo(model, {
-          maybeStartDate: () => Option.some(date),
-          endDate: DatePicker.reflectMinDate(Option.some(date)),
-        }),
-      }),
-    ClearedDate: () => model => ({
+const foldStartDateOutMessage = DatePicker.OutMessage.match<
+  Update.Step<Model, Message>
+>({
+  ChangedViewMonth: () => model => ({ model }),
+  SelectedDate:
+    ({ date }) =>
+    model => ({
       model: evo(model, {
-        maybeStartDate: () => Option.none(),
-        endDate: DatePicker.reflectMinDate(Option.none()),
+        maybeStartDate: () => Option.some(date),
+        endDate: DatePicker.reflectMinDate(Option.some(date)),
       }),
     }),
+  ClearedDate: () => model => ({
+    model: evo(model, {
+      maybeStartDate: () => Option.none(),
+      endDate: DatePicker.reflectMinDate(Option.none()),
+    }),
   }),
-)
+})
 
 const foldStartDate = Update.foldChild({
   update: DatePicker.update,
@@ -114,26 +113,25 @@ const foldStartDate = Update.foldChild({
   foldOutMessage: foldStartDateOutMessage,
 })
 
-const foldEndDateOutMessage = M.type<DatePicker.OutMessage>().pipe(
-  M.withReturnType<Update.Step<Model, Message>>(),
-  M.tagsExhaustive({
-    ChangedViewMonth: () => model => ({ model }),
-    SelectedDate:
-      ({ date }) =>
-      model => ({
-        model: evo(model, {
-          maybeEndDate: () => Option.some(date),
-          startDate: DatePicker.reflectMaxDate(Option.some(date)),
-        }),
-      }),
-    ClearedDate: () => model => ({
+const foldEndDateOutMessage = DatePicker.OutMessage.match<
+  Update.Step<Model, Message>
+>({
+  ChangedViewMonth: () => model => ({ model }),
+  SelectedDate:
+    ({ date }) =>
+    model => ({
       model: evo(model, {
-        maybeEndDate: () => Option.none(),
-        startDate: DatePicker.reflectMaxDate(Option.none()),
+        maybeEndDate: () => Option.some(date),
+        startDate: DatePicker.reflectMaxDate(Option.some(date)),
       }),
     }),
+  ClearedDate: () => model => ({
+    model: evo(model, {
+      maybeEndDate: () => Option.none(),
+      startDate: DatePicker.reflectMaxDate(Option.none()),
+    }),
   }),
-)
+})
 
 const foldEndDate = Update.foldChild({
   update: DatePicker.update,

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

@@ -1,4 +1,4 @@
-import { Array, Crypto, Effect, Match as M, Schema as S } from 'effect'
+import { Array, Crypto, Effect, Schema } from 'effect'
 import { Calendar, Command, Update } from 'foldkit'
 import { type CalendarDate } from 'foldkit/calendar'
 import { defineMessageUnion } from 'foldkit/message'
@@ -10,8 +10,8 @@ import * as Entry from './entry'
 
 // MODEL
 
-export const Model = S.Struct({
-  entries: S.Array(Entry.Model),
+export const Model = Schema.Struct({
+  entries: Schema.Array(Entry.Model),
   today: Calendar.CalendarDate,
 })
 export type Model = typeof Model.Type
@@ -20,11 +20,11 @@ export type Model = typeof Model.Type
 
 export const Message = defineMessageUnion({
   ClickedAddEntry: {},
-  SucceededGenerateEntryId: { entryId: S.String },
+  SucceededGenerateEntryId: { entryId: Schema.String },
   FailedGenerateEntryId: {},
-  RemovedEntry: { entryId: S.String },
+  RemovedEntry: { entryId: Schema.String },
   GotEntryMessage: {
-    entryId: S.String,
+    entryId: Schema.String,
     message: Entry.Message,
   },
 })
@@ -57,16 +57,13 @@ export const GenerateEntryId = Command.define('GenerateEntryId', {
 const foldEntryOutMessage: (
   entryId: string,
 ) => (outMessage: Entry.OutMessage) => Update.Step<Model, Message> = entryId =>
-  M.type<Entry.OutMessage>().pipe(
-    M.withReturnType<Update.Step<Model, Message>>(),
-    M.tagsExhaustive({
-      Removed: () => model => ({
-        model: evo(model, {
-          entries: Array.filter(entry => entry.id !== entryId),
-        }),
+  Entry.OutMessage.match<Update.Step<Model, Message>>({
+    Removed: () => model => ({
+      model: evo(model, {
+        entries: Array.filter(entry => entry.id !== entryId),
       }),
     }),
-  )
+  })
 
 const foldEntry = (entryId: string) =>
   Update.foldChild({

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

@@ -1,4 +1,4 @@
-import { Array, Match as M, Option, pipe } from 'effect'
+import { Array, Option, pipe } from 'effect'
 import { Update } from 'foldkit'
 import { evo } from 'foldkit/struct'
 
@@ -87,14 +87,14 @@ const foldAttachments = Update.foldChild({
   toParentMessage: message => Message.GotAttachmentsMessage({ message }),
 })
 
-const foldStepMenuOutMessage = M.type<Menu.OutMessage<Step.Step>>().pipe(
-  M.withReturnType<Update.Step<Model, Message>>(),
-  M.tagsExhaustive({
-    Selected:
-      ({ value }) =>
-      model => ({ model: evo(model, { currentStep: () => value }) }),
-  }),
-)
+const foldStepMenuOutMessage = Menu.OutMessage.match<
+  Update.Step<Model, Message>,
+  Menu.OutMessage<Step.Step>
+>({
+  Selected:
+    ({ value }) =>
+    model => ({ model: evo(model, { currentStep: () => value }) }),
+})
 
 const foldStepMenu = Update.foldChild({
   update: StepMenu.update,
@@ -104,14 +104,14 @@ const foldStepMenu = Update.foldChild({
   foldOutMessage: foldStepMenuOutMessage,
 })
 
-const foldStepTabsOutMessage = M.type<Tabs.OutMessage<Step.Step>>().pipe(
-  M.withReturnType<Update.Step<Model, Message>>(),
-  M.tagsExhaustive({
-    Selected:
-      ({ value }) =>
-      model => ({ model: evo(model, { currentStep: () => value }) }),
-  }),
-)
+const foldStepTabsOutMessage = Tabs.OutMessage.match<
+  Update.Step<Model, Message>,
+  Tabs.OutMessage<Step.Step>
+>({
+  Selected:
+    ({ value }) =>
+    model => ({ model: evo(model, { currentStep: () => value }) }),
+})
 
 const foldStepTabs = Update.foldChild({
   update: StepTabs.update,

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

@@ -1,5 +1,5 @@
 import clsx from 'clsx'
-import { Array, Match as M, Number, Option } from 'effect'
+import { Array, Match, Number, Option } from 'effect'
 import { File, Submodel } from 'foldkit'
 import type { Html, HtmlBuilder } from 'foldkit/html'
 
@@ -12,13 +12,13 @@ const BYTES_PER_KB = 1024
 const BYTES_PER_MB = BYTES_PER_KB * BYTES_PER_KB
 
 const formatFileSize = (bytes: number): string =>
-  M.value(bytes).pipe(
-    M.when(Number.isLessThan(BYTES_PER_KB), () => `${bytes} B`),
-    M.when(
+  Match.value(bytes).pipe(
+    Match.when(Number.isLessThan(BYTES_PER_KB), () => `${bytes} B`),
+    Match.when(
       Number.isLessThan(BYTES_PER_MB),
       () => `${(bytes / BYTES_PER_KB).toFixed(1)} KB`,
     ),
-    M.orElse(() => `${(bytes / BYTES_PER_MB).toFixed(1)} MB`),
+    Match.orElse(() => `${(bytes / BYTES_PER_MB).toFixed(1)} MB`),
   )
 
 const dropZoneClassName =

package/dist/templates/examples/job-application/src/view/datePicker.ts

@@ -1,4 +1,4 @@
-import { Match as M, Option } from 'effect'
+import { Match, Option } from 'effect'
 import { type CalendarDate } from 'foldkit/calendar'
 import { type Html, inertHtml as ih } from 'foldkit/html'
 
@@ -51,8 +51,8 @@ const monthYearButtonClassName =
   'flex h-full w-full items-center justify-center rounded-md text-sm text-gray-900 tabular-nums cursor-pointer hover:bg-gray-100 group-data-[today]:ring-1 group-data-[today]:ring-gray-400 group-data-[selected]:bg-indigo-600 group-data-[selected]:text-white! group-data-[selected]:hover:bg-indigo-600 group-data-[focused]:outline-2 group-data-[focused]:outline-offset-2 group-data-[focused]:outline-indigo-500 group-data-[disabled]:cursor-not-allowed group-data-[disabled]:opacity-40'
 
 export const calendarView = (attributes: Calendar.CalendarAttributes): Html =>
-  M.value(attributes).pipe(
-    M.tagsExhaustive({
+  Match.value(attributes).pipe(
+    Match.tagsExhaustive({
       Days: days =>
         ih.div(
           [...days.root, ih.Class(calendarWrapperClassName)],

package/dist/templates/examples/job-application/src/view/field.ts

@@ -1,5 +1,5 @@
 import clsx from 'clsx'
-import { Match as M } from 'effect'
+import { Match } from 'effect'
 import { FieldValidation } from 'foldkit'
 import { type Field } from 'foldkit/fieldValidation'
 import type { Html, HtmlBuilder } from 'foldkit/html'
@@ -50,17 +50,17 @@ export const inputField = <ParentMessage>(
                   ],
                   [config.label],
                 ),
-                ...M.value(config.field).pipe(
-                  M.tag('Validating', () => [
+                ...Match.value(config.field).pipe(
+                  Match.tag('Validating', () => [
                     h.span(
                       [h.Class('text-blue-600 text-sm animate-spin')],
                       ['◐'],
                     ),
                   ]),
-                  M.tag('Valid', () => [
+                  Match.tag('Valid', () => [
                     h.span([h.Class('text-green-600 text-sm')], ['✓']),
                   ]),
-                  M.orElse(() => []),
+                  Match.orElse(() => []),
                 ),
               ],
             ),