@stone-js/starters 0.8.12 → 0.8.14

package/monorepo-declarative/apps/web/tsconfig.json

@@ -0,0 +1,33 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "useDefineForClassFields": true,
+    "module": "ESNext",
+    "lib": ["ES2020", "DOM", "DOM.Iterable"],
+    "skipLibCheck": true,
+    "experimentalDecorators": true,
+
+    /* Bundler mode */
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "isolatedModules": true,
+    "moduleDetection": "force",
+    "noEmit": true,
+    "jsx": "react-jsx",
+    "resolveJsonModule": true,
+
+    /* Linting */
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedSideEffectImports": true,
+
+    "types": ["node", "vite/client", "vitest/globals"],
+  },
+  "include": [
+    "app",
+    "tests",
+    "vitest.config.ts"
+  ]
+}

package/monorepo-declarative/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "acme",
+  "private": true,
+  "version": "1.0.0",
+  "description": "One domain, two applications: a Stone.js monorepo starter.",
+  "license": "MIT",
+  "type": "module",
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "scripts": {
+    "build": "pnpm --filter @acme/domain build && pnpm --filter @acme/web build",
+    "dev:web": "pnpm --filter @acme/web dev",
+    "dev:mobile": "pnpm --filter @acme/mobile start",
+    "test": "pnpm -r run test",
+    "typecheck": "pnpm -r run typecheck",
+    "domain": "pnpm --filter @acme/domain"
+  },
+  "devDependencies": {
+    "typescript": "~5.9.0"
+  },
+  "pnpm": {
+    "overrides": {
+      "react": "19.2.3",
+      "react-dom": "19.2.3"
+    }
+  }
+}

package/monorepo-declarative/packages/domain/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright © 2026 Stone Foundation
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/monorepo-declarative/packages/domain/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@acme/domain",
+  "private": true,
+  "version": "1.0.0",
+  "description": "The application's domain: entities and behaviour, with no platform in sight.",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": ["dist"],
+  "scripts": {
+    "build": "rimraf dist && tsc -p tsconfig.build.json",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:cvg": "npm run test -- --coverage"
+  },
+  "dependencies": {
+    "@stone-js/core": "^0.8.13"
+  },
+  "devDependencies": {
+    "@vitest/coverage-v8": "^3.0.9",
+    "rimraf": "^6.0.1",
+    "typescript": "~5.9.0",
+    "vitest": "^3.0.9"
+  }
+}

package/monorepo-declarative/packages/domain/src/Task.ts

@@ -0,0 +1,16 @@
+/**
+ * A task.
+ *
+ * The whole of what this application is about, and it says nothing about HTTP, about a screen, or
+ * about where it is stored. That is the point: a domain that names a platform can only run on it.
+ */
+export interface Task {
+  /** Stable identifier, used in routes. */
+  id: string
+
+  /** What the user wrote. */
+  title: string
+
+  /** Whether it is done. */
+  done: boolean
+}

package/monorepo-declarative/packages/domain/src/TaskService.ts

@@ -0,0 +1,75 @@
+import { Task } from './Task.js'
+
+/**
+ * The application's one piece of behaviour.
+ *
+ * It takes the tasks it works on, so a starter can hand it an array and a real application can hand
+ * it a repository, without a line here changing. What matters is what it does *not* import: no
+ * `Request`, no `Response`, no `window`, no `View`. It is the half of the application that is true
+ * on a server, in a browser, on a phone and at the edge, and it is written once.
+ */
+export class TaskService {
+  private readonly tasks: Task[]
+
+  /**
+   * Create the service.
+   *
+   * @param tasks - Where the tasks are kept. The caller owns it, which is what lets a test hand in
+   *   its own and an application hand in its store.
+   * @returns The service.
+   */
+  static create (tasks: Task[]): TaskService {
+    return new TaskService(tasks)
+  }
+
+  /**
+   * @param tasks - Where the tasks are kept.
+   */
+  private constructor (tasks: Task[]) {
+    this.tasks = tasks
+  }
+
+  /**
+   * Every task.
+   *
+   * @returns A copy, so a caller cannot reach into the service's state.
+   */
+  all (): Task[] {
+    return [...this.tasks]
+  }
+
+  /**
+   * One task by its identifier.
+   *
+   * @param id - The identifier.
+   * @returns The task, or `undefined` when there is none.
+   */
+  find (id: string): Task | undefined {
+    return this.tasks.find((task) => task.id === id)
+  }
+
+  /**
+   * Flip a task's state.
+   *
+   * @param id - The identifier.
+   * @returns The task as it now is, or `undefined` when there is none.
+   */
+  toggle (id: string): Task | undefined {
+    const task = this.find(id)
+
+    if (task === undefined) { return undefined }
+
+    task.done = !task.done
+
+    return task
+  }
+
+  /**
+   * How many are left.
+   *
+   * @returns The number of tasks not done.
+   */
+  remaining (): number {
+    return this.tasks.filter((task) => !task.done).length
+  }
+}

package/monorepo-declarative/packages/domain/src/index.ts

@@ -0,0 +1,33 @@
+import { Task } from './Task.js'
+import { defineService } from '@stone-js/core'
+import { TaskService } from './TaskService.js'
+
+export * from './Task.js'
+export * from './TaskService.js'
+
+/**
+ * Where the tasks actually live, for a starter that installs no database.
+ *
+ * A module-level array, deliberately, because Stone.js gives every event its own container: a
+ * service holding state in itself would forget it between two events. A real application injects a
+ * repository here and this constant disappears; nothing in `TaskService` changes.
+ */
+const store: Task[] = [
+  { id: '1', title: 'Write the domain once', done: true },
+  { id: '2', title: 'Run it on the web', done: true },
+  { id: '3', title: 'Run the same code on a phone', done: false }
+]
+
+/**
+ * The domain, as something an application can activate.
+ *
+ * A module is activated by its decorator or by its blueprint, never by a third thing. A shared
+ * package takes the blueprint path: decorating `TaskService` would mean the build has to discover
+ * it, and a build discovers what is under `app/`, not what is in `node_modules`. So the domain hands
+ * out a blueprint fragment instead, and each application activates it in its own `@StoneApp`.
+ *
+ * A factory rather than a class, because `TaskService` has a private constructor and is created
+ * through `create`, which is the convention across Stone.js. The alias is what a page asks for:
+ * `constructor ({ tasks }: { tasks: TaskService })`.
+ */
+export const domainBlueprint = defineService(() => TaskService.create(store), { alias: 'tasks' })

package/monorepo-declarative/packages/domain/tests/TaskService.spec.ts

@@ -0,0 +1,73 @@
+import { Task, TaskService } from '../src/index.js'
+
+/**
+ * The domain, tested on its own.
+ *
+ * No application, no kernel, no adapter, no renderer, because none of them are involved. This is
+ * the half of the codebase that both applications share, and it is also the half that is cheapest
+ * to test: plain objects in, plain objects out, in milliseconds.
+ */
+describe('TaskService', () => {
+  const seed = (): Task[] => [
+    { id: '1', title: 'Done already', done: true },
+    { id: '2', title: 'Still to do', done: false }
+  ]
+
+  it('lists the tasks it was given', () => {
+    const service = TaskService.create(seed())
+
+    expect(service.all()).toHaveLength(2)
+    expect(service.all()[0].title).toBe('Done already')
+  })
+
+  it('hands out a copy, so a caller cannot reach into its state', () => {
+    const service = TaskService.create(seed())
+
+    service.all().push({ id: '3', title: 'Injected', done: false })
+
+    expect(service.all()).toHaveLength(2)
+  })
+
+  it('finds a task by its identifier', () => {
+    const service = TaskService.create(seed())
+
+    expect(service.find('2')?.title).toBe('Still to do')
+  })
+
+  it('has nothing to find for an unknown identifier', () => {
+    const service = TaskService.create(seed())
+
+    expect(service.find('nope')).toBeUndefined()
+  })
+
+  it('flips a task and reports it as it now is', () => {
+    const service = TaskService.create(seed())
+
+    expect(service.toggle('2')?.done).toBe(true)
+    expect(service.find('2')?.done).toBe(true)
+  })
+
+  it('flips back', () => {
+    const service = TaskService.create(seed())
+
+    service.toggle('1')
+
+    expect(service.find('1')?.done).toBe(false)
+  })
+
+  it('has nothing to flip for an unknown identifier', () => {
+    const service = TaskService.create(seed())
+
+    expect(service.toggle('nope')).toBeUndefined()
+  })
+
+  it('counts what is left', () => {
+    const service = TaskService.create(seed())
+
+    expect(service.remaining()).toBe(1)
+
+    service.toggle('2')
+
+    expect(service.remaining()).toBe(0)
+  })
+})

package/monorepo-declarative/packages/domain/tsconfig.build.json

@@ -0,0 +1,4 @@
+{
+  "extends": "./tsconfig.json",
+  "include": ["src"]
+}

package/monorepo-declarative/packages/domain/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "lib": ["ES2022"],
+    "strict": true,
+    "declaration": true,
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "outDir": "dist",
+    "types": ["vitest/globals"]
+  },
+  "include": ["src", "tests"]
+}

package/monorepo-declarative/packages/domain/vitest.config.ts

@@ -0,0 +1,15 @@
+import { defineConfig } from 'vitest/config'
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+    include: ['./tests/**/*.{test,spec}.ts'],
+    coverage: {
+      provider: 'v8',
+      include: ['src/**/*.ts'],
+      reporter: ['text', 'html'],
+      reportsDirectory: './coverage'
+    }
+  }
+})