create-foldkit-app 0.32.0 → 0.32.1

package/dist/templates/examples/ssg/src/route.ts

@@ -1,11 +1,11 @@
-import { Schema as S, pipe } from 'effect'
+import { Schema, pipe } from 'effect'
 import { Route } from 'foldkit'
 import { defineRouteUnion, literal } from 'foldkit/route'
 
 export const AppRoute = defineRouteUnion({
   Home: {},
   About: {},
-  NotFound: { path: S.String },
+  NotFound: { path: Schema.String },
 })
 
 export type AppRoute = typeof AppRoute.Type

package/dist/templates/examples/ssr/src/cookie.ts

@@ -1,4 +1,4 @@
-import { Number as Number_, Option, Record, pipe } from 'effect'
+import { Number, Option, Record, pipe } from 'effect'
 import { Cookies } from 'effect/unstable/http'
 
 export const COUNT_COOKIE = 'foldkit-ssr-count'
@@ -7,7 +7,7 @@ export const readCountCookie = (cookieHeader: string): number =>
   pipe(
     Cookies.parseHeader(cookieHeader),
     Record.get(COUNT_COOKIE),
-    Option.flatMap(Number_.parse),
-    Option.filter(Number.isSafeInteger),
+    Option.flatMap(Number.parse),
+    Option.filter(globalThis.Number.isSafeInteger),
     Option.getOrElse(() => 0),
   )

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

@@ -1,4 +1,4 @@
-import { Effect, Schema as S } from 'effect'
+import { Effect, Schema } from 'effect'
 import { Command, Runtime, type Update } from 'foldkit'
 import { type Document, type Html, type HtmlBuilder } from 'foldkit/html'
 import { defineMessageUnion } from 'foldkit/message'
@@ -10,19 +10,19 @@ import { COUNT_COOKIE } from './cookie'
 
 // MODEL
 
-export const Model = S.Struct({
-  count: S.Number,
-  renderedAt: S.String,
-  renderedOn: S.Literals(['Server', 'Client']),
+export const Model = Schema.Struct({
+  count: Schema.Number,
+  renderedAt: Schema.String,
+  renderedOn: Schema.Literals(['Server', 'Client']),
 })
 export type Model = typeof Model.Type
 
 // FLAGS
 
-export const Flags = S.Struct({
-  initialCount: S.Number,
-  renderedAt: S.String,
-  renderedOn: S.Literals(['Server', 'Client']),
+export const Flags = Schema.Struct({
+  initialCount: Schema.Number,
+  renderedAt: Schema.String,
+  renderedOn: Schema.Literals(['Server', 'Client']),
 })
 export type Flags = typeof Flags.Type
 
@@ -62,7 +62,7 @@ export const update = (model: Model, message: Message) =>
 const COUNT_COOKIE_MAX_AGE_SECONDS = 31536000
 
 export const PersistCount = Command.define('PersistCount', {
-  args: { count: S.Number },
+  args: { count: Schema.Number },
   messages: [Message.CompletedPersistCount],
   execute: ({ count }) =>
     Effect.try(() => {

package/dist/templates/examples/state-machine/src/main.ts

@@ -2,10 +2,10 @@ import {
   Array,
   Duration,
   Effect,
-  Match as M,
+  Match,
   Number,
   Option,
-  Schema as S,
+  Schema,
   String,
   flow,
   pipe,
@@ -21,9 +21,9 @@ import { RadioGroup } from '@foldkit/ui'
 
 // MODEL
 
-export const Discount = S.Struct({
-  code: S.String,
-  percentOff: S.Number,
+export const Discount = Schema.Struct({
+  code: Schema.String,
+  percentOff: Schema.Number,
 })
 
 export const Promo = defineTaggedUnion({
@@ -33,31 +33,34 @@ export const Promo = defineTaggedUnion({
 })
 
 export const CheckoutState = defineTaggedUnion({
-  Cart: { isShippingRequired: S.Boolean },
-  Shipping: { isShippingRequired: S.Boolean },
+  Cart: { isShippingRequired: Schema.Boolean },
+  Shipping: { isShippingRequired: Schema.Boolean },
   Payment: {
-    isPaymentMethodSelected: S.Boolean,
-    isShippingRequired: S.Boolean,
+    isPaymentMethodSelected: Schema.Boolean,
+    isShippingRequired: Schema.Boolean,
   },
   Review: {
-    isPaymentMethodSelected: S.Boolean,
-    isShippingRequired: S.Boolean,
-    isTermsAccepted: S.Boolean,
+    isPaymentMethodSelected: Schema.Boolean,
+    isShippingRequired: Schema.Boolean,
+    isTermsAccepted: Schema.Boolean,
     promo: Promo,
-    promoCodeInput: S.String,
+    promoCodeInput: Schema.String,
+  },
+  Placing: {
+    isShippingRequired: Schema.Boolean,
+    maybeDiscount: Schema.Option(Discount),
   },
-  Placing: { isShippingRequired: S.Boolean, maybeDiscount: S.Option(Discount) },
   Confirmed: {
-    isShippingRequired: S.Boolean,
-    maybeDiscount: S.Option(Discount),
-    orderId: S.String,
+    isShippingRequired: Schema.Boolean,
+    maybeDiscount: Schema.Option(Discount),
+    orderId: Schema.String,
   },
-  Cancelled: { isShippingRequired: S.Boolean },
+  Cancelled: { isShippingRequired: Schema.Boolean },
 })
 
-export const TransitionLogEntry = S.Struct({
-  id: S.Number,
-  summary: S.String,
+export const TransitionLogEntry = Schema.Struct({
+  id: Schema.Number,
+  summary: Schema.String,
 })
 export type TransitionLogEntry = typeof TransitionLogEntry.Type
 
@@ -76,11 +79,11 @@ export const editionName = (isShippingRequired: boolean): string =>
 
 export const EditionRadioGroup = RadioGroup.create()
 
-export const Model = S.Struct({
+export const Model = Schema.Struct({
   checkout: CheckoutState,
   editionRadioGroup: RadioGroup.Model,
-  transitionLog: S.Array(TransitionLogEntry),
-  nextTransitionLogId: S.Number,
+  transitionLog: Schema.Array(TransitionLogEntry),
+  nextTransitionLogId: Schema.Number,
 })
 export type Model = typeof Model.Type
 
@@ -92,13 +95,13 @@ export const Message = defineMessageUnion({
   ClickedCancel: {},
   ClickedPlaceOrder: {},
   ClickedStartOver: {},
-  ToggledPaymentMethod: { isSelected: S.Boolean },
-  SelectedEdition: { isShippingRequired: S.Boolean },
+  ToggledPaymentMethod: { isSelected: Schema.Boolean },
+  SelectedEdition: { isShippingRequired: Schema.Boolean },
   GotEditionRadioGroupMessage: { message: RadioGroup.Message },
-  ToggledTermsAccepted: { isAccepted: S.Boolean },
-  UpdatedPromoCode: { value: S.String },
+  ToggledTermsAccepted: { isAccepted: Schema.Boolean },
+  UpdatedPromoCode: { value: Schema.String },
   SubmittedPromoCode: {},
-  SucceededPlaceOrder: { orderId: S.String },
+  SucceededPlaceOrder: { orderId: Schema.String },
 })
 
 export type Message = typeof Message.Type
@@ -108,7 +111,7 @@ export type Message = typeof Message.Type
 const PLACE_ORDER_DELAY = Duration.seconds(1)
 
 export const PlaceOrder = Command.define('PlaceOrder', {
-  args: { isShippingRequired: S.Boolean },
+  args: { isShippingRequired: Schema.Boolean },
   messages: [Message.SucceededPlaceOrder],
   execute: ({ isShippingRequired }) =>
     Effect.gen(function* () {
@@ -129,9 +132,9 @@ const PROMO_DISCOUNTS: ReadonlyArray<typeof Discount.Type> = [
 export const promoToMaybeDiscount = (
   promo: typeof Promo.Type,
 ): Option.Option<typeof Discount.Type> =>
-  M.value(promo).pipe(
-    M.tags({ AppliedPromo: appliedPromo => appliedPromo.discount }),
-    M.option,
+  Match.value(promo).pipe(
+    Match.tags({ AppliedPromo: appliedPromo => appliedPromo.discount }),
+    Match.option,
   )
 
 export const isReviewReady = (
@@ -352,8 +355,8 @@ export const TRANSITION_LOG_LIMIT = 20
 const resultToTransitionSummary = (
   result: Machine.TransitionResult<typeof CheckoutState.Type, Message>,
 ): string =>
-  M.value(result).pipe(
-    M.tagsExhaustive({
+  Match.value(result).pipe(
+    Match.tagsExhaustive({
       Transitioned: ({ from, messageTag, target }) =>
         `${from} -> ${target} on ${messageTag}`,
       Ignored: ({ messageTag, stateTag }) =>
@@ -368,8 +371,8 @@ const stepMachine =
 
     const { state: nextCheckout } = result
 
-    const transitionCommands = M.value(result).pipe(
-      M.tagsExhaustive({
+    const transitionCommands = Match.value(result).pipe(
+      Match.tagsExhaustive({
         Transitioned: ({ commands }) => commands,
         Ignored: () => [],
       }),
@@ -393,17 +396,16 @@ const stepMachine =
     }
   }
 
-const foldEditionRadioGroupOutMessage = M.type<RadioGroup.OutMessage>().pipe(
-  M.withReturnType<Update.Step<Model, Message>>(),
-  M.tagsExhaustive({
-    Selected: ({ value }) =>
-      stepMachine(
-        Message.SelectedEdition({
-          isShippingRequired: value === HARDCOVER_EDITION,
-        }),
-      ),
-  }),
-)
+const foldEditionRadioGroupOutMessage = RadioGroup.OutMessage.match<
+  Update.Step<Model, Message>
+>({
+  Selected: ({ value }) =>
+    stepMachine(
+      Message.SelectedEdition({
+        isShippingRequired: value === HARDCOVER_EDITION,
+      }),
+    ),
+})
 
 const foldEditionRadioGroup = Update.foldChild({
   update: EditionRadioGroup.update,
@@ -415,12 +417,12 @@ const foldEditionRadioGroup = Update.foldChild({
 })
 
 export const update = (model: Model, message: Message) =>
-  M.value(message).pipe(
-    M.withReturnType<UpdateReturn>(),
-    M.tag('GotEditionRadioGroupMessage', ({ message }) =>
+  Match.value(message).pipe(
+    Match.withReturnType<UpdateReturn>(),
+    Match.tag('GotEditionRadioGroupMessage', ({ message }) =>
       foldEditionRadioGroup(model, message),
     ),
-    M.tag(
+    Match.tag(
       'ClickedContinue',
       'ClickedBack',
       'ClickedCancel',
@@ -434,5 +436,5 @@ export const update = (model: Model, message: Message) =>
       'SucceededPlaceOrder',
       () => stepMachine(message)(model),
     ),
-    M.exhaustive,
+    Match.exhaustive,
   )

package/dist/templates/examples/state-machine/src/view.ts

@@ -1,5 +1,5 @@
 import { clsx } from 'clsx'
-import { Array, Match as M, Option, pipe } from 'effect'
+import { Array, Match, Option, pipe } from 'effect'
 import { Document, Html, HtmlBuilder } from 'foldkit/html'
 
 import { Button, Checkbox, Input, RadioGroup } from '@foldkit/ui'
@@ -80,15 +80,15 @@ const progressSteps: ReadonlyArray<string> = [
 const stateToMaybeProgressStep = (
   state: typeof CheckoutState.Type,
 ): Option.Option<string> =>
-  M.value(state).pipe(
-    M.tags({
+  Match.value(state).pipe(
+    Match.tags({
       Cart: () => 'Bag',
       Shipping: () => 'Delivery',
       Payment: () => 'Payment',
       Review: () => 'Review',
       Cancelled: () => 'Bag',
     }),
-    M.option,
+    Match.option,
   )
 
 const currentProgressIndex = (state: typeof CheckoutState.Type): number =>
@@ -140,13 +140,13 @@ const orderPricing = (
 const stateToMaybeDiscount = (
   state: typeof CheckoutState.Type,
 ): Option.Option<typeof Discount.Type> =>
-  M.value(state).pipe(
-    M.tags({
+  Match.value(state).pipe(
+    Match.tags({
       Review: reviewState => promoToMaybeDiscount(reviewState.promo),
       Placing: placingState => placingState.maybeDiscount,
       Confirmed: confirmedState => confirmedState.maybeDiscount,
     }),
-    M.option,
+    Match.option,
     Option.flatten,
   )
 

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

@@ -2,7 +2,7 @@ import {
   Clock,
   Duration,
   Effect,
-  Schema as S,
+  Schema,
   Stream,
   String,
   flow,
@@ -19,10 +19,10 @@ const TICK_INTERVAL_MS = 10
 
 // MODEL
 
-export const Model = S.Struct({
-  elapsedMs: S.Number,
-  isRunning: S.Boolean,
-  startTime: S.Number,
+export const Model = Schema.Struct({
+  elapsedMs: Schema.Number,
+  isRunning: Schema.Boolean,
+  startTime: Schema.Number,
 })
 export type Model = typeof Model.Type
 
@@ -30,11 +30,11 @@ export type Model = typeof Model.Type
 
 export const Message = defineMessageUnion({
   ClickedStart: {},
-  CompletedDetermineStartTime: { startTime: S.Number },
+  CompletedDetermineStartTime: { startTime: Schema.Number },
   ClickedStop: {},
   ClickedReset: {},
   Ticked: {},
-  CompletedDetermineTickTime: { elapsedMs: S.Number },
+  CompletedDetermineTickTime: { elapsedMs: Schema.Number },
 })
 
 export type Message = typeof Message.Type
@@ -42,7 +42,7 @@ export type Message = typeof Message.Type
 // COMMAND
 
 export const DetermineStartTime = Command.define('DetermineStartTime', {
-  args: { elapsedMs: S.Number },
+  args: { elapsedMs: Schema.Number },
   messages: [Message.CompletedDetermineStartTime],
   execute: ({ elapsedMs }) =>
     Effect.gen(function* () {
@@ -52,7 +52,7 @@ export const DetermineStartTime = Command.define('DetermineStartTime', {
 })
 
 export const DetermineTickTime = Command.define('DetermineTickTime', {
-  args: { startTime: S.Number },
+  args: { startTime: Schema.Number },
   messages: [Message.CompletedDetermineTickTime],
   execute: ({ startTime }) =>
     Effect.gen(function* () {
@@ -117,7 +117,7 @@ export const init: Runtime.ApplicationInit<Model, Message> = () => ({
 
 export const subscriptions = Subscription.make<Model, Message>()(entry => ({
   tick: entry(
-    { isRunning: S.Boolean },
+    { isRunning: Schema.Boolean },
     {
       modelToDependencies: model => ({ isRunning: model.isRunning }),
       dependenciesToStream: ({ isRunning }) =>

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

@@ -3,10 +3,10 @@ import {
   Array,
   Clock,
   Effect,
-  Match as M,
+  Match,
   Option,
   Random,
-  Schema as S,
+  Schema,
   String,
 } from 'effect'
 import { KeyValueStore } from 'effect/unstable/persistence'
@@ -25,31 +25,31 @@ const TODOS_STORAGE_KEY = 'todos'
 
 // MODEL
 
-const Todo = S.Struct({
-  id: S.String,
-  text: S.String,
-  completed: S.Boolean,
-  createdAt: S.Number,
+const Todo = Schema.Struct({
+  id: Schema.String,
+  text: Schema.String,
+  completed: Schema.Boolean,
+  createdAt: Schema.Number,
 })
 type Todo = typeof Todo.Type
 
-const Todos = S.Array(Todo)
+const Todos = Schema.Array(Todo)
 type Todos = typeof Todos.Type
 
-const TodosJsonString = S.fromJsonString(S.toCodecJson(Todos))
+const TodosJsonString = Schema.fromJsonString(Schema.toCodecJson(Todos))
 
-const Filter = S.Literals(['All', 'Active', 'Completed'])
+const Filter = Schema.Literals(['All', 'Active', 'Completed'])
 type Filter = typeof Filter.Type
 
 export const EditingState = defineTaggedUnion({
   NotEditing: {},
-  Editing: { id: S.String, text: S.String },
+  Editing: { id: Schema.String, text: Schema.String },
 })
 export type EditingState = typeof EditingState.Type
 
-export const Model = S.Struct({
+export const Model = Schema.Struct({
   todos: Todos,
-  newTodoText: S.String,
+  newTodoText: Schema.String,
   filter: Filter,
   editing: EditingState,
 })
@@ -58,13 +58,17 @@ export type Model = typeof Model.Type
 // MESSAGE
 
 export const Message = defineMessageUnion({
-  UpdatedNewTodo: { text: S.String },
-  UpdatedEditingTodo: { text: S.String },
+  UpdatedNewTodo: { text: Schema.String },
+  UpdatedEditingTodo: { text: Schema.String },
   AddedTodo: {},
-  CompletedGenerateTodo: { id: S.String, timestamp: S.Number, text: S.String },
-  DeletedTodo: { id: S.String },
-  ToggledTodo: { id: S.String },
-  StartedEditing: { id: S.String },
+  CompletedGenerateTodo: {
+    id: Schema.String,
+    timestamp: Schema.Number,
+    text: Schema.String,
+  },
+  DeletedTodo: { id: Schema.String },
+  ToggledTodo: { id: Schema.String },
+  StartedEditing: { id: Schema.String },
   SavedEdit: {},
   CancelledEdit: {},
   ToggledAll: {},
@@ -77,8 +81,8 @@ export type Message = typeof Message.Type
 
 // FLAGS
 
-export const Flags = S.Struct({
-  todos: S.Option(Todos),
+export const Flags = Schema.Struct({
+  todos: Schema.Option(Todos),
 })
 export type Flags = typeof Flags.Type
 
@@ -267,7 +271,7 @@ export const update = (model: Model, message: Message) =>
 // COMMAND
 
 export const GenerateTodo = Command.define('GenerateTodo', {
-  args: { text: S.String },
+  args: { text: Schema.String },
   messages: [Message.CompletedGenerateTodo],
   execute: ({ text }) =>
     Effect.gen(function* () {
@@ -285,7 +289,10 @@ export const SaveTodos = Command.define('SaveTodos', {
   execute: ({ todos }) =>
     Effect.gen(function* () {
       const store = yield* KeyValueStore.KeyValueStore
-      yield* store.set(TODOS_STORAGE_KEY, S.encodeSync(TodosJsonString)(todos))
+      yield* store.set(
+        TODOS_STORAGE_KEY,
+        Schema.encodeSync(TodosJsonString)(todos),
+      )
       return Message.SucceededSaveTodos({ todos })
     }).pipe(
       Effect.catch(() => Effect.succeed(Message.FailedSaveTodos())),
@@ -541,11 +548,11 @@ const footerView = (
   })
 
 const filterTodos = (todos: Todos, filter: Filter): Todos =>
-  M.value(filter).pipe(
-    M.when('All', () => todos),
-    M.when('Active', () => Array.filter(todos, todo => !todo.completed)),
-    M.when('Completed', () => Array.filter(todos, todo => todo.completed)),
-    M.exhaustive,
+  Match.value(filter).pipe(
+    Match.when('All', () => todos),
+    Match.when('Active', () => Array.filter(todos, todo => !todo.completed)),
+    Match.when('Completed', () => Array.filter(todos, todo => todo.completed)),
+    Match.exhaustive,
   )
 
 export const view = (model: Model, h: HtmlBuilder<Message>): Document => {
@@ -615,11 +622,11 @@ export const view = (model: Model, h: HtmlBuilder<Message>): Document => {
               h.div(
                 [h.Class('text-center text-gray-500 py-8')],
                 [
-                  M.value(model.filter).pipe(
-                    M.when('All', () => 'No todos yet. Add one above!'),
-                    M.when('Active', () => 'No active todos'),
-                    M.when('Completed', () => 'No completed todos'),
-                    M.exhaustive,
+                  Match.value(model.filter).pipe(
+                    Match.when('All', () => 'No todos yet. Add one above!'),
+                    Match.when('Active', () => 'No active todos'),
+                    Match.when('Completed', () => 'No completed todos'),
+                    Match.exhaustive,
                   ),
                 ],
               ),
@@ -649,7 +656,7 @@ export const flags: Effect.Effect<Flags> = Effect.gen(function* () {
     Option.fromNullishOr(yield* store.get(TODOS_STORAGE_KEY)),
   )
 
-  const decodeTodos = S.decodeEffect(TodosJsonString)
+  const decodeTodos = Schema.decodeEffect(TodosJsonString)
   const todos = yield* decodeTodos(todosJson)
 
   return { todos: Option.some(todos) }