create-foldkit-app 0.27.3 → 0.28.0

package/dist/templates/examples/slow-warnings/src/scene.test.ts

@@ -0,0 +1,57 @@
+import { click, expect, given, role, scene, text } from 'foldkit/scene'
+import { describe, test } from 'vitest'
+
+import { type Model, update, view } from './main'
+
+const initialModel: Model = {
+  activeWorkload: 'Idle',
+  nextWarningId: 1,
+  warnings: [],
+  patchRows: 0,
+  patchRun: 0,
+}
+
+describe('view', () => {
+  test('renders all workload controls', () => {
+    scene(
+      { update, view },
+      given(initialModel),
+      expect(text('Slow Warnings Lab')).toExist(),
+      expect(role('button', { name: 'Run update work' })).toExist(),
+      expect(role('button', { name: 'Run view work' })).toExist(),
+      expect(role('button', { name: 'Run patch work' })).toExist(),
+      expect(role('button', { name: 'Run dependency extraction' })).toExist(),
+    )
+  })
+
+  test('clicking patch work renders patch rows', () => {
+    scene(
+      { update, view },
+      given(initialModel),
+      click(role('button', { name: 'Run patch work' })),
+      expect(text('Patch row 1')).toExist(),
+    )
+  })
+
+  test('clear removes recorded warnings', () => {
+    scene(
+      { update, view },
+      given({
+        ...initialModel,
+        warnings: [
+          {
+            id: 1,
+            phase: 'Update',
+            durationMs: 12,
+            thresholdMs: 4,
+            trigger: 'ClickedRunUpdateWork',
+            details: 'Update work exceeded the threshold.',
+          },
+        ],
+      }),
+      expect(text('Update exceeded 4ms')).toExist(),
+      click(role('button', { name: 'Clear' })),
+      expect(text('Run a workload to record a warning.')).toExist(),
+    )
+  })
+})

package/dist/templates/examples/slow-warnings/src/story.test.ts

@@ -0,0 +1,118 @@
+import { Command, given, message, model, story } from 'foldkit/story'
+import { describe, expect, test } from 'vitest'
+
+import { Message, type Model, update } from './main'
+
+const initialModel: Model = {
+  activeWorkload: 'Idle',
+  nextWarningId: 1,
+  warnings: [],
+  patchRows: 0,
+  patchRun: 0,
+}
+
+describe('update', () => {
+  test('ClickedRunUpdateWork records update workload state', () => {
+    story(
+      update,
+      given(initialModel),
+      message(Message.ClickedRunUpdateWork()),
+      Command.expectNone(),
+      model(model => {
+        expect(model.activeWorkload).toBe('Update')
+      }),
+    )
+  })
+
+  test('ClickedRunViewWork records view workload state', () => {
+    story(
+      update,
+      given(initialModel),
+      message(Message.ClickedRunViewWork()),
+      model(model => {
+        expect(model.activeWorkload).toBe('View')
+      }),
+    )
+  })
+
+  test('ClickedRunPatchWork mounts a large patch surface', () => {
+    story(
+      update,
+      given(initialModel),
+      message(Message.ClickedRunPatchWork()),
+      model(model => {
+        expect(model.activeWorkload).toBe('Patch')
+        expect(model.patchRows).toBeGreaterThan(0)
+        expect(model.patchRun).toBe(1)
+      }),
+    )
+  })
+
+  test('ClickedRunSubscriptionDependenciesWork records subscription dependency workload state', () => {
+    story(
+      update,
+      given(initialModel),
+      message(Message.ClickedRunSubscriptionDependenciesWork()),
+      model(model => {
+        expect(model.activeWorkload).toBe('SubscriptionDependencies')
+      }),
+    )
+  })
+
+  test('RecordedSlowWarning stores the warning and clears active workload', () => {
+    story(
+      update,
+      given(initialModel),
+      message(
+        Message.RecordedSlowWarning({
+          report: {
+            phase: 'Update',
+            durationMs: 12,
+            thresholdMs: 4,
+            trigger: 'ClickedRunUpdateWork',
+            details: 'Update work exceeded the threshold.',
+          },
+        }),
+      ),
+      model(model => {
+        expect(model.activeWorkload).toBe('Idle')
+        expect(model.nextWarningId).toBe(2)
+        expect(model.warnings).toEqual([
+          {
+            id: 1,
+            phase: 'Update',
+            durationMs: 12,
+            thresholdMs: 4,
+            trigger: 'ClickedRunUpdateWork',
+            details: 'Update work exceeded the threshold.',
+          },
+        ])
+      }),
+    )
+  })
+
+  test('ClickedClearWarnings clears warnings without resetting the patch surface', () => {
+    story(
+      update,
+      given({
+        ...initialModel,
+        patchRows: 4000,
+        warnings: [
+          {
+            id: 1,
+            phase: 'Patch',
+            durationMs: 16,
+            thresholdMs: 8,
+            trigger: 'ClickedRunPatchWork',
+            details: 'Patch work exceeded the threshold.',
+          },
+        ],
+      }),
+      message(Message.ClickedClearWarnings()),
+      model(model => {
+        expect(model.warnings).toEqual([])
+        expect(model.patchRows).toBe(4000)
+      }),
+    )
+  })
+})

package/dist/templates/examples/slow-warnings/src/styles.css

@@ -0,0 +1 @@
+@import 'tailwindcss';

package/dist/templates/examples/slow-warnings/src/vitest-setup.ts

@@ -0,0 +1,3 @@
+import { setup } from 'foldkit/test/vitest'
+
+setup()

package/dist/templates/examples/snake/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "snake-example",
+  "private": true,
+  "version": "0.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@effect/platform-browser": "4.0.0-rc.109",
+    "@tailwindcss/vite": "^4.3.1",
+    "effect": "4.0.0-rc.109",
+    "foldkit": "workspace:*",
+    "tailwindcss": "^4.3.1"
+  },
+  "devDependencies": {
+    "@foldkit/devtools": "workspace:*",
+    "@foldkit/vite-plugin": "workspace:*",
+    "@trivago/prettier-plugin-sort-imports": "^6.0.2",
+    "happy-dom": "^20.10.4",
+    "prettier": "^3.8.4",
+    "typescript": "^6.0.3",
+    "vite": "^8.0.16",
+    "vitest": "^4.1.9"
+  }
+}

package/dist/templates/examples/snake/src/constants.ts

@@ -0,0 +1,11 @@
+export const GAME = {
+  GRID_SIZE: 20,
+  INITIAL_POSITION: { x: 10, y: 10 },
+  INITIAL_DIRECTION: 'Right',
+  POINTS_PER_APPLE: 10,
+} as const
+
+export const GAME_SPEED = {
+  MIN_INTERVAL: 80,
+  BASE_INTERVAL: 150,
+} as const

package/dist/templates/examples/snake/src/domain/apple.ts

@@ -0,0 +1,22 @@
+import { Effect, Random, Schedule } from 'effect'
+
+import { GAME } from '../constants'
+import { Position } from './position'
+import * as Snake from './snake'
+
+export const generatePosition = (snake: Snake.Snake) =>
+  Effect.gen(function* () {
+    const x = yield* Random.nextIntBetween(0, GAME.GRID_SIZE, {
+      halfOpen: true,
+    })
+    const y = yield* Random.nextIntBetween(0, GAME.GRID_SIZE, {
+      halfOpen: true,
+    })
+    const pos: Position = { x, y }
+
+    if (Snake.contains(snake, pos)) {
+      return yield* Effect.fail('PositionCollision' as const)
+    } else {
+      return pos
+    }
+  }).pipe(Effect.retry(Schedule.forever), Effect.orDie)

package/dist/templates/examples/snake/src/domain/direction.ts

@@ -0,0 +1,17 @@
+import { Match, Schema } from 'effect'
+
+export const Direction = Schema.Literals(['Up', 'Down', 'Left', 'Right'])
+export type Direction = typeof Direction.Type
+
+export const opposite = (direction: Direction): Direction =>
+  Match.value(direction).pipe(
+    Match.withReturnType<Direction>(),
+    Match.when('Up', () => 'Down'),
+    Match.when('Down', () => 'Up'),
+    Match.when('Left', () => 'Right'),
+    Match.when('Right', () => 'Left'),
+    Match.exhaustive,
+  )
+
+export const isOpposite = (a: Direction, b: Direction): boolean =>
+  opposite(a) === b

package/dist/templates/examples/snake/src/domain/index.ts

@@ -0,0 +1,4 @@
+export * as Position from './position'
+export * as Direction from './direction'
+export * as Snake from './snake'
+export * as Apple from './apple'

package/dist/templates/examples/snake/src/domain/position.ts

@@ -0,0 +1,32 @@
+import { Match, Schema } from 'effect'
+
+import { GAME } from '../constants'
+import * as Direction from './direction'
+
+export const Position = Schema.Struct({
+  x: Schema.Number,
+  y: Schema.Number,
+})
+
+export const equivalence = Schema.toEquivalence(Position)
+
+export type Position = typeof Position.Type
+
+export const wrap = ({ x, y }: Position): Position => ({
+  x: x < 0 ? GAME.GRID_SIZE - 1 : x >= GAME.GRID_SIZE ? 0 : x,
+  y: y < 0 ? GAME.GRID_SIZE - 1 : y >= GAME.GRID_SIZE ? 0 : y,
+})
+
+export const move = (
+  pos: Position,
+  direction: Direction.Direction,
+): Position => {
+  const next = Match.value(direction).pipe(
+    Match.when('Up', () => ({ x: pos.x, y: pos.y - 1 })),
+    Match.when('Down', () => ({ x: pos.x, y: pos.y + 1 })),
+    Match.when('Left', () => ({ x: pos.x - 1, y: pos.y })),
+    Match.when('Right', () => ({ x: pos.x + 1, y: pos.y })),
+    Match.exhaustive,
+  )
+  return wrap(next)
+}

package/dist/templates/examples/snake/src/domain/snake.ts

@@ -0,0 +1,43 @@
+import { Array, Schema as S } from 'effect'
+
+import type { Direction } from './direction'
+import * as Position from './position'
+
+export const INITIAL_LENGTH = 3
+
+export const Snake = S.NonEmptyArray(Position.Position)
+export type Snake = typeof Snake.Type
+
+export const create = (startPos: Position.Position): Snake =>
+  Array.makeBy(INITIAL_LENGTH, i => ({
+    x: startPos.x - i,
+    y: startPos.y,
+  }))
+
+export const move = (snake: Snake, direction: Direction): Snake =>
+  Array.matchLeft(snake, {
+    onEmpty: () => snake,
+    onNonEmpty: (head, tail) => {
+      const newHead = Position.move(head, direction)
+      return [newHead, head, ...Array.dropRight(tail, 1)]
+    },
+  })
+
+export const grow = (snake: Snake, direction: Direction): Snake =>
+  Array.matchLeft(snake, {
+    onEmpty: () => snake,
+    onNonEmpty: (head, tail) => {
+      const newHead = Position.move(head, direction)
+      return [newHead, head, ...tail]
+    },
+  })
+
+export const hasCollision = (snake: Snake): boolean =>
+  Array.matchLeft(snake, {
+    onEmpty: () => false,
+    onNonEmpty: (head, tail) =>
+      Array.some(tail, segment => Position.equivalence(head, segment)),
+  })
+
+export const contains = (snake: Snake, pos: Position.Position): boolean =>
+  Array.some(snake, segment => Position.equivalence(segment, pos))

package/dist/templates/examples/snake/src/entry.ts

@@ -0,0 +1,17 @@
+import { Runtime } from 'foldkit'
+
+import { Message, Model, init, subscriptions, update, view } from './main'
+
+const application = Runtime.makeApplication({
+  Model,
+  init,
+  update,
+  view,
+  subscriptions,
+  container: document.getElementById('root'),
+  devTools: {
+    Message,
+  },
+})
+
+Runtime.run(application)