create-foldkit-app 0.32.0 → 0.32.1

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

@@ -1,4 +1,4 @@
-import { Array, Match as M, Number, Option, Result } from 'effect'
+import { Array, Number, Option, Result } from 'effect'
 import { Command, Update } from 'foldkit'
 import { evo } from 'foldkit/struct'
 
@@ -223,14 +223,13 @@ const appendGeneratedParticle =
     }
   }
 
-const foldFlowStrengthSliderOutMessage = M.type<Slider.OutMessage>().pipe(
-  M.withReturnType<Update.Step<Model, Message>>(),
-  M.tagsExhaustive({
-    ChangedValue:
-      ({ value }) =>
-      model => ({ model: evo(model, { flowStrength: () => value }) }),
-  }),
-)
+const foldFlowStrengthSliderOutMessage = Slider.OutMessage.match<
+  Update.Step<Model, Message>
+>({
+  ChangedValue:
+    ({ value }) =>
+    model => ({ model: evo(model, { flowStrength: () => value }) }),
+})
 
 const foldFlowStrengthSlider = Update.foldChild({
   update: Slider.update,
@@ -241,14 +240,13 @@ const foldFlowStrengthSlider = Update.foldChild({
   foldOutMessage: foldFlowStrengthSliderOutMessage,
 })
 
-const foldNoiseScaleSliderOutMessage = M.type<Slider.OutMessage>().pipe(
-  M.withReturnType<Update.Step<Model, Message>>(),
-  M.tagsExhaustive({
-    ChangedValue:
-      ({ value }) =>
-      model => ({ model: evo(model, { noiseScale: () => value }) }),
-  }),
-)
+const foldNoiseScaleSliderOutMessage = Slider.OutMessage.match<
+  Update.Step<Model, Message>
+>({
+  ChangedValue:
+    ({ value }) =>
+    model => ({ model: evo(model, { noiseScale: () => value }) }),
+})
 
 const foldNoiseScaleSlider = Update.foldChild({
   update: Slider.update,

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

@@ -3,10 +3,10 @@ import {
   Array,
   Duration,
   Effect,
-  Match as M,
+  Match,
   Number,
   Option,
-  Schema as S,
+  Schema,
   pipe,
 } from 'effect'
 import { Command, Runtime, type Update } from 'foldkit'
@@ -16,20 +16,20 @@ import { evo } from 'foldkit/struct'
 
 // MODEL
 
-export const UploadStatus = S.Literals(['Uploading', 'Done', 'Cancelled'])
+export const UploadStatus = Schema.Literals(['Uploading', 'Done', 'Cancelled'])
 export type UploadStatus = typeof UploadStatus.Type
 
-export const Upload = S.Struct({
-  id: S.Number,
-  fileName: S.String,
-  sizeMegabytes: S.Number,
+export const Upload = Schema.Struct({
+  id: Schema.Number,
+  fileName: Schema.String,
+  sizeMegabytes: Schema.Number,
   status: UploadStatus,
 })
 export type Upload = typeof Upload.Type
 
-export const Model = S.Struct({
-  uploadId: S.Number,
-  uploads: S.Array(Upload),
+export const Model = Schema.Struct({
+  uploadId: Schema.Number,
+  uploads: Schema.Array(Upload),
 })
 export type Model = typeof Model.Type
 
@@ -37,12 +37,12 @@ export type Model = typeof Model.Type
 
 export const Message = defineMessageUnion({
   ClickedStartUpload: {},
-  ClickedCancelUpload: { uploadId: S.Number },
+  ClickedCancelUpload: { uploadId: Schema.Number },
   ClickedCancelAllUploads: {},
-  ClickedRestartUpload: { uploadId: S.Number },
-  SucceededUploadFile: { uploadId: S.Number },
+  ClickedRestartUpload: { uploadId: Schema.Number },
+  SucceededUploadFile: { uploadId: Schema.Number },
   CompletedCancelUploadFile: {
-    uploadId: S.Number,
+    uploadId: Schema.Number,
     outcome: Command.Interruptible.Outcome,
   },
 })
@@ -62,7 +62,10 @@ export const init: Runtime.ApplicationInit<Model, Message> = () => ({
 
 // FAKE FILES
 
-export const FakeFile = S.Struct({ name: S.String, sizeMegabytes: S.Number })
+export const FakeFile = Schema.Struct({
+  name: Schema.String,
+  sizeMegabytes: Schema.Number,
+})
 export type FakeFile = typeof FakeFile.Type
 
 export const FAKE_FILES: Array.NonEmptyReadonlyArray<FakeFile> = [
@@ -84,11 +87,11 @@ const fakeFileForUpload = (uploadId: number): FakeFile =>
 
 const MILLISECONDS_PER_MEGABYTE = 100
 
-export const UploadKey = S.Struct({ uploadId: S.Number })
+export const UploadKey = Schema.Struct({ uploadId: Schema.Number })
 export type UploadKey = typeof UploadKey.Type
 
 export const UploadFile = Command.define('UploadFile', {
-  args: { ...UploadKey.fields, sizeMegabytes: S.Number },
+  args: { ...UploadKey.fields, sizeMegabytes: Schema.Number },
   messages: [Message.SucceededUploadFile],
   interrupt: {
     keyFields: ['uploadId'],
@@ -194,19 +197,19 @@ export const update = (model: Model, message: Message) =>
 // VIEW
 
 const badgeClass = (status: UploadStatus): string =>
-  M.value(status).pipe(
-    M.when('Uploading', () => 'bg-blue-100 text-blue-700'),
-    M.when('Done', () => 'bg-green-100 text-green-700'),
-    M.when('Cancelled', () => 'bg-gray-200 text-gray-600'),
-    M.exhaustive,
+  Match.value(status).pipe(
+    Match.when('Uploading', () => 'bg-blue-100 text-blue-700'),
+    Match.when('Done', () => 'bg-green-100 text-green-700'),
+    Match.when('Cancelled', () => 'bg-gray-200 text-gray-600'),
+    Match.exhaustive,
   )
 
 const ACTION_BUTTON_CLASS =
   'px-3 py-1 text-sm font-medium rounded-md border transition'
 
 const uploadActionView = (upload: Upload, h: HtmlBuilder<Message>): Html =>
-  M.value(upload.status).pipe(
-    M.when('Uploading', () =>
+  Match.value(upload.status).pipe(
+    Match.when('Uploading', () =>
       h.keyed('button')(
         'Uploading',
         [
@@ -222,7 +225,7 @@ const uploadActionView = (upload: Upload, h: HtmlBuilder<Message>): Html =>
         ['Cancel'],
       ),
     ),
-    M.when('Cancelled', () =>
+    Match.when('Cancelled', () =>
       h.keyed('button')(
         'Cancelled',
         [
@@ -238,8 +241,8 @@ const uploadActionView = (upload: Upload, h: HtmlBuilder<Message>): Html =>
         ['Restart'],
       ),
     ),
-    M.when('Done', () => h.empty),
-    M.exhaustive,
+    Match.when('Done', () => h.empty),
+    Match.exhaustive,
   )
 
 const uploadView = (upload: Upload, h: HtmlBuilder<Message>): Html =>

package/dist/templates/examples/job-application/src/domain/proficiencyLevel.ts

@@ -1,6 +1,6 @@
-import { Schema as S } from 'effect'
+import { Schema } from 'effect'
 
-export const ProficiencyLevel = S.Literals([
+export const ProficiencyLevel = Schema.Literals([
   'Beginner',
   'Intermediate',
   'Advanced',

package/dist/templates/examples/job-application/src/domain/pronounOption.ts

@@ -1,6 +1,6 @@
-import { Schema as S } from 'effect'
+import { Schema } from 'effect'
 
-export const PronounOption = S.Literals([
+export const PronounOption = Schema.Literals([
   'He/Him',
   'She/Her',
   'They/Them',

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

@@ -1,6 +1,6 @@
-import { Match as M, Schema as S } from 'effect'
+import { Match, Schema } from 'effect'
 
-export const Step = S.Literals([
+export const Step = Schema.Literals([
   'PersonalInfo',
   'WorkHistory',
   'Education',
@@ -16,13 +16,13 @@ export const all = Step.literals
 export const indexOf = (step: Step): number => all.indexOf(step)
 
 export const show = (step: Step): string =>
-  M.value(step).pipe(
-    M.when('PersonalInfo', () => 'Personal Info'),
-    M.when('WorkHistory', () => 'Work History'),
-    M.when('Education', () => 'Education'),
-    M.when('Skills', () => 'Skills'),
-    M.when('CoverLetter', () => 'Cover Letter'),
-    M.when('Attachments', () => 'Attachments'),
-    M.when('Review', () => 'Review'),
-    M.exhaustive,
+  Match.value(step).pipe(
+    Match.when('PersonalInfo', () => 'Personal Info'),
+    Match.when('WorkHistory', () => 'Work History'),
+    Match.when('Education', () => 'Education'),
+    Match.when('Skills', () => 'Skills'),
+    Match.when('CoverLetter', () => 'Cover Letter'),
+    Match.when('Attachments', () => 'Attachments'),
+    Match.when('Review', () => 'Review'),
+    Match.exhaustive,
   )

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

@@ -1,4 +1,4 @@
-import { Crypto, Effect, Schema as S } from 'effect'
+import { Crypto, Effect, Schema } from 'effect'
 import { Calendar, Runtime } from 'foldkit'
 
 import { BrowserCrypto } from '@effect/platform-browser'
@@ -19,11 +19,11 @@ import { view } from './view'
 
 // FLAGS
 
-export const Flags = S.Struct({
+export const Flags = Schema.Struct({
   today: Calendar.CalendarDate,
-  initialWorkHistoryEntryId: S.String,
-  initialEducationEntryId: S.String,
-  initialSkillsEntryId: S.String,
+  initialWorkHistoryEntryId: Schema.String,
+  initialEducationEntryId: Schema.String,
+  initialSkillsEntryId: Schema.String,
 })
 export type Flags = typeof Flags.Type
 

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

@@ -1,4 +1,4 @@
-import { Schema as S } from 'effect'
+import { Schema } from 'effect'
 import { defineMessageUnion } from 'foldkit/message'
 
 import { Menu, Tabs } from '@foldkit/ui'
@@ -38,7 +38,7 @@ export const Message = defineMessageUnion({
   ToggledPreview: {},
   ClickedSubmit: {},
   SucceededSubmitApplication: {},
-  FailedSubmitApplication: { error: S.String },
+  FailedSubmitApplication: { error: Schema.String },
 })
 
 export type Message = typeof Message.Type

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

@@ -1,4 +1,4 @@
-import { Schema as S } from 'effect'
+import { Schema } from 'effect'
 import { defineTaggedUnion } from 'foldkit/schema'
 
 import { Menu, Tabs } from '@foldkit/ui'
@@ -19,13 +19,13 @@ export const Submission = defineTaggedUnion({
   NotSubmitted: {},
   Submitting: {},
   SubmitSuccess: {},
-  SubmitError: { error: S.String },
+  SubmitError: { error: Schema.String },
 })
 export type Submission = typeof Submission.Type
 
 // MODEL
 
-export const Model = S.Struct({
+export const Model = Schema.Struct({
   currentStep: Step.Step,
   personalInfo: PersonalInfo.Model,
   workHistory: WorkHistory.Model,
@@ -33,10 +33,10 @@ export const Model = S.Struct({
   skills: Skills.Model,
   coverLetter: CoverLetter.Model,
   attachments: Attachments.Model,
-  isPreviewVisible: S.Boolean,
+  isPreviewVisible: Schema.Boolean,
   submission: Submission,
   stepMenu: Menu.Model,
   stepTabs: Tabs.Model,
-  isSubmitAttempted: S.Boolean,
+  isSubmitAttempted: Schema.Boolean,
 })
 export type Model = typeof Model.Type

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

@@ -1,4 +1,4 @@
-import { Array, Match as M, Option, Schema as S, pipe } from 'effect'
+import { Array, Option, Schema, pipe } from 'effect'
 import { File, Update } from 'foldkit'
 import { defineMessageUnion } from 'foldkit/message'
 import { evo } from 'foldkit/struct'
@@ -7,11 +7,11 @@ import { FileDrop } from '@foldkit/ui'
 
 // MODEL
 
-export const Model = S.Struct({
+export const Model = Schema.Struct({
   resumeDrop: FileDrop.Model,
-  maybeResume: S.Option(File.File),
+  maybeResume: Schema.Option(File.File),
   additionalFilesDrop: FileDrop.Model,
-  additionalFiles: S.Array(File.File),
+  additionalFiles: Schema.Array(File.File),
 })
 export type Model = typeof Model.Type
 
@@ -21,7 +21,7 @@ export const Message = defineMessageUnion({
   GotResumeDropMessage: { message: FileDrop.Message },
   GotAdditionalFilesDropMessage: { message: FileDrop.Message },
   RemovedResume: {},
-  RemovedAdditionalFile: { fileIndex: S.Number },
+  RemovedAdditionalFile: { fileIndex: Schema.Number },
 })
 
 export type Message = typeof Message.Type
@@ -37,24 +37,23 @@ export const init = (): Model => ({
 
 // UPDATE
 
-const foldResumeDropOutMessage = M.type<FileDrop.OutMessage>().pipe(
-  M.withReturnType<Update.Step<Model, Message>>(),
-  M.tagsExhaustive({
-    ReceivedFiles:
-      ({ files }) =>
-      model => ({
-        model: evo(model, {
-          maybeResume: () =>
-            pipe(
-              files,
-              Array.head,
-              Option.orElse(() => model.maybeResume),
-            ),
-        }),
+const foldResumeDropOutMessage = FileDrop.OutMessage.match<
+  Update.Step<Model, Message>
+>({
+  ReceivedFiles:
+    ({ files }) =>
+    model => ({
+      model: evo(model, {
+        maybeResume: () =>
+          pipe(
+            files,
+            Array.head,
+            Option.orElse(() => model.maybeResume),
+          ),
       }),
-    RejectedNonFiles: () => model => ({ model }),
-  }),
-)
+    }),
+  RejectedNonFiles: () => model => ({ model }),
+})
 
 const foldResumeDrop = Update.foldChild({
   update: FileDrop.update,
@@ -65,19 +64,18 @@ const foldResumeDrop = Update.foldChild({
   foldOutMessage: foldResumeDropOutMessage,
 })
 
-const foldAdditionalFilesDropOutMessage = M.type<FileDrop.OutMessage>().pipe(
-  M.withReturnType<Update.Step<Model, Message>>(),
-  M.tagsExhaustive({
-    ReceivedFiles:
-      ({ files }) =>
-      model => ({
-        model: evo(model, {
-          additionalFiles: Array.appendAll(files),
-        }),
+const foldAdditionalFilesDropOutMessage = FileDrop.OutMessage.match<
+  Update.Step<Model, Message>
+>({
+  ReceivedFiles:
+    ({ files }) =>
+    model => ({
+      model: evo(model, {
+        additionalFiles: Array.appendAll(files),
       }),
-    RejectedNonFiles: () => model => ({ model }),
-  }),
-)
+    }),
+  RejectedNonFiles: () => model => ({ model }),
+})
 
 const foldAdditionalFilesDrop = Update.foldChild({
   update: FileDrop.update,

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

@@ -1,19 +1,19 @@
-import { Schema as S } from 'effect'
+import { Schema } from 'effect'
 import { type Update } from 'foldkit'
 import { defineMessageUnion } from 'foldkit/message'
 import { evo } from 'foldkit/struct'
 
 // MODEL
 
-export const Model = S.Struct({
-  content: S.String,
+export const Model = Schema.Struct({
+  content: Schema.String,
 })
 export type Model = typeof Model.Type
 
 // MESSAGE
 
 export const Message = defineMessageUnion({
-  UpdatedContent: { value: S.String },
+  UpdatedContent: { value: Schema.String },
 })
 
 export type Message = typeof Message.Type

package/dist/templates/examples/job-application/src/step/education/education.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/step/education/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,
@@ -35,14 +35,14 @@ const validateFieldOfStudy = validate(fieldOfStudyRules)
 
 // MODEL
 
-export const Model = S.Struct({
-  id: S.String,
-  school: Field(S.String),
-  degree: Field(S.String),
-  fieldOfStudy: Field(S.String),
-  maybeGraduationYear: S.Option(S.String),
+export const Model = Schema.Struct({
+  id: Schema.String,
+  school: Field(Schema.String),
+  degree: Field(Schema.String),
+  fieldOfStudy: Field(Schema.String),
+  maybeGraduationYear: Schema.Option(Schema.String),
   graduationYearListbox: Listbox.Model,
-  isCurrentlyEnrolled: S.Boolean,
+  isCurrentlyEnrolled: Schema.Boolean,
 })
 export type Model = typeof Model.Type
 
@@ -51,11 +51,11 @@ const GraduationYearListbox = Listbox.create<string>()
 // MESSAGE
 
 export const Message = defineMessageUnion({
-  UpdatedSchool: { value: S.String },
-  UpdatedDegree: { value: S.String },
-  UpdatedFieldOfStudy: { value: S.String },
+  UpdatedSchool: { value: Schema.String },
+  UpdatedDegree: { value: Schema.String },
+  UpdatedFieldOfStudy: { value: Schema.String },
   GotGraduationYearListboxMessage: { message: Listbox.Message },
-  ToggledCurrentlyEnrolled: { isChecked: S.Boolean },
+  ToggledCurrentlyEnrolled: { isChecked: Schema.Boolean },
   ClickedRemoveSelf: {},
 })
 
@@ -87,16 +87,15 @@ export const init = (entryId: string): Model => ({
 
 // UPDATE
 
-const foldGraduationYearListboxOutMessage = M.type<Listbox.OutMessage>().pipe(
-  M.withReturnType<Update.Step<Model, Message>>(),
-  M.tagsExhaustive({
-    Selected:
-      ({ value }) =>
-      model => ({
-        model: evo(model, { maybeGraduationYear: () => Option.some(value) }),
-      }),
-  }),
-)
+const foldGraduationYearListboxOutMessage = Listbox.OutMessage.match<
+  Update.Step<Model, Message>
+>({
+  Selected:
+    ({ value }) =>
+    model => ({
+      model: evo(model, { maybeGraduationYear: () => Option.some(value) }),
+    }),
+})
 
 const foldGraduationYearListbox = Update.foldChild({
   update: GraduationYearListbox.update,