@starci/hfs 3.0.0 → 4.0.1

package/templates/fe/skeleton/apps/__app__/src/app/globals.css

@@ -1 +1,6 @@
 @import "tailwindcss";
+@import "@heroui/styles/css";
+@import "@starci/grammar/common.css";
+
+/* The grammar's renderers spell their layout in Tailwind utilities inside node_modules, which Tailwind never scans by default. */
+@source "../../../../../node_modules/@starci/grammar/dist";

package/templates/fe/skeleton/apps/__app__/src/components/composites/FailureScreen/index.tsx

@@ -0,0 +1,28 @@
+import { Button, GrammarRoot, Heading, PageContainer, WorkspaceShell } from "@starci/grammar/common"
+
+/** Props for {@link FailureScreen}. */
+type FailureScreenProps = {
+    /** What failed, said to the reader. */
+    readonly title: string
+    /** The label of the one recovery action. */
+    readonly retryLabel: string
+    /** Runs the recovery: the boundary re-renders what failed. */
+    readonly onRetry: () => void
+}
+
+/** A whole-screen failure with its one recovery action: the drawing both error boundaries share. */
+export const FailureScreen = (props: FailureScreenProps) => (
+    <GrammarRoot>
+        <WorkspaceShell
+            primaryLabel={props.title}
+            primary={
+                <PageContainer measure="reading">
+                    <Heading level={1}>{props.title}</Heading>
+                    <Button variant="danger" onPress={props.onRetry}>
+                        {props.retryLabel}
+                    </Button>
+                </PageContainer>
+            }
+        />
+    </GrammarRoot>
+)

package/templates/fe/skeleton/apps/__app__/src/features/layouts/LocaleShell/index.tsx

@@ -0,0 +1,35 @@
+import type { Metadata } from "next"
+import { notFound } from "next/navigation"
+import { hasLocale, NextIntlClientProvider } from "next-intl"
+import { getMessages, getTranslations, setRequestLocale } from "next-intl/server"
+import type { ReactNode } from "react"
+import { siteUrl } from "@/modules/config"
+import { routing } from "@/modules/i18n"
+
+type LocaleShellProps = {
+    readonly lang: string
+    readonly children: ReactNode
+}
+
+/** The document title and the absolute base of every metadata URL, for the language in the address. */
+export const localeMetadata = async (lang: string): Promise<Metadata> => {
+    if (!hasLocale(routing.locales, lang)) notFound()
+    const t = await getTranslations({ locale: lang, namespace: "app" })
+    return { title: t("title"), metadataBase: new URL(siteUrl()) }
+}
+
+/** The document of one route language: `<html lang>` from the address and the catalog handed to client components. */
+export const LocaleShell = async (props: LocaleShellProps) => {
+    if (!hasLocale(routing.locales, props.lang)) notFound()
+    setRequestLocale(props.lang)
+    const messages = await getMessages()
+    return (
+        <html lang={props.lang}>
+            <body className="min-h-dvh">
+                <NextIntlClientProvider locale={props.lang} messages={messages}>
+                    {props.children}
+                </NextIntlClientProvider>
+            </body>
+        </html>
+    )
+}

package/templates/fe/skeleton/apps/__app__/src/features/pages/ErrorPage/component.tsx

@@ -0,0 +1,21 @@
+import { FailureScreen } from "@/components/composites/FailureScreen"
+
+/** Props for {@link ErrorPageBase}. */
+export type ErrorPageBaseProps = {
+    /** Whole-screen situations this surface settles; the error page only ever shows the failure. */
+    readonly state: "failed"
+    /** The words the failure shows. */
+    readonly props: {
+        readonly title: string
+        readonly retryLabel: string
+    }
+    /** What the surface reports upward. */
+    readonly on: {
+        readonly retry: () => void
+    }
+}
+
+/** Draw the failure of the locale segment with its one recovery action. */
+export const ErrorPageBase = (props: ErrorPageBaseProps) => (
+    <FailureScreen title={props.props.title} retryLabel={props.props.retryLabel} onRetry={props.on.retry} />
+)

package/templates/fe/skeleton/apps/__app__/src/features/pages/ErrorPage/index.tsx

@@ -0,0 +1,17 @@
+import { useTranslations } from "next-intl"
+import { ErrorPageBase } from "./component"
+
+/** The public props of the locale error page: the boundary hands it the retry. */
+type ErrorPageProps = { readonly onRetry: () => void }
+
+/** A render failure of the locale segment shows this instead of a blank page; retry re-renders the segment. */
+export const ErrorPage = (props: ErrorPageProps) => {
+    const t = useTranslations("errors.page")
+    return (
+        <ErrorPageBase
+            state="failed"
+            props={{ title: t("title"), retryLabel: t("retry") }}
+            on={{ retry: props.onRetry }}
+        />
+    )
+}

package/templates/fe/skeleton/apps/__app__/src/features/pages/GlobalErrorPage/component.tsx

@@ -0,0 +1,26 @@
+import { FailureScreen } from "@/components/composites/FailureScreen"
+
+/** Props for {@link GlobalErrorPageBase}. */
+export type GlobalErrorPageBaseProps = {
+    /** Whole-screen situations this surface settles; the global error page only ever shows the failure. */
+    readonly state: "failed"
+    /** The language of the document and the words the failure shows. */
+    readonly props: {
+        readonly lang: string
+        readonly title: string
+        readonly retryLabel: string
+    }
+    /** What the surface reports upward. */
+    readonly on: {
+        readonly retry: () => void
+    }
+}
+
+/** Draw the whole document, because this boundary replaces the root layout that would have drawn it. */
+export const GlobalErrorPageBase = (props: GlobalErrorPageBaseProps) => (
+    <html lang={props.props.lang}>
+        <body>
+            <FailureScreen title={props.props.title} retryLabel={props.props.retryLabel} onRetry={props.on.retry} />
+        </body>
+    </html>
+)

package/templates/fe/skeleton/apps/__app__/src/features/pages/GlobalErrorPage/index.tsx

@@ -0,0 +1,15 @@
+import { DEFAULT_LOCALE } from "@/modules/i18n"
+import messages from "@/modules/i18n/messages/vi.json"
+import { GlobalErrorPageBase } from "./component"
+
+/** The public props of the last-resort error page: the boundary hands it the retry. */
+type GlobalErrorPageProps = { readonly onRetry: () => void }
+
+/** The last-resort boundary above the locale layout: it has no provider, so it reads the default catalog directly. */
+export const GlobalErrorPage = (props: GlobalErrorPageProps) => (
+    <GlobalErrorPageBase
+        state="failed"
+        props={{ lang: DEFAULT_LOCALE, title: messages.errors.global.title, retryLabel: messages.errors.global.retry }}
+        on={{ retry: props.onRetry }}
+    />
+)

package/templates/fe/skeleton/apps/__app__/src/features/pages/HomePage/component.tsx

@@ -0,0 +1,25 @@
+import { GrammarRoot, Heading, PageContainer, WorkspaceShell } from "@starci/grammar/common"
+
+/** Props for {@link HomePageBase}. */
+export type HomePageBaseProps = {
+    /** Whole-screen situations this surface settles; the home page only ever shows its title. */
+    readonly state: "ready"
+    /** The words the page shows. */
+    readonly props: { readonly title: string }
+    /** What the surface reports upward; the page reports nothing. */
+    readonly on: Record<never, never>
+}
+
+/** Draw the front door of the app. */
+export const HomePageBase = (props: HomePageBaseProps) => (
+    <GrammarRoot>
+        <WorkspaceShell
+            primaryLabel={props.props.title}
+            primary={
+                <PageContainer measure="reading">
+                    <Heading level={1}>{props.props.title}</Heading>
+                </PageContainer>
+            }
+        />
+    </GrammarRoot>
+)

package/templates/fe/skeleton/apps/__app__/src/features/pages/HomePage/index.tsx

@@ -0,0 +1,15 @@
+import type { Metadata } from "next"
+import { getTranslations } from "next-intl/server"
+import { HomePageBase } from "./component"
+
+/** The document title of the home page, from the catalog of the requested locale. */
+export const homeMetadata = async (): Promise<Metadata> => {
+    const t = await getTranslations("home")
+    return { title: t("title") }
+}
+
+/** The first page of the app: a server component, so no catalog is shipped for it. */
+export const HomePage = async () => {
+    const t = await getTranslations("home")
+    return <HomePageBase state="ready" props={{ title: t("title") }} on={{}} />
+}

package/templates/fe/skeleton/apps/__app__/src/features/pages/LoadingPage/component.tsx

@@ -0,0 +1,27 @@
+import { GrammarRoot, PageContainer, Text, WorkspaceShell } from "@starci/grammar/common"
+
+/** Props for {@link LoadingPageBase}. */
+export type LoadingPageBaseProps = {
+    /** Whole-screen situations this surface settles; the loading page only ever waits. */
+    readonly state: "loading"
+    /** The words the wait announces. */
+    readonly props: { readonly message: string }
+    /** What the surface reports upward; a wait reports nothing. */
+    readonly on: Record<never, never>
+}
+
+/** Draw the wait as one politely announced line. */
+export const LoadingPageBase = (props: LoadingPageBaseProps) => (
+    <GrammarRoot>
+        <WorkspaceShell
+            primaryLabel={props.props.message}
+            primary={
+                <PageContainer measure="reading">
+                    <Text live="polite" tone="muted">
+                        {props.props.message}
+                    </Text>
+                </PageContainer>
+            }
+        />
+    </GrammarRoot>
+)

package/templates/fe/skeleton/apps/__app__/src/features/pages/LoadingPage/index.tsx

@@ -0,0 +1,8 @@
+import { getTranslations } from "next-intl/server"
+import { LoadingPageBase } from "./component"
+
+/** Shown while a route of the locale segment resolves. */
+export const LoadingPage = async () => {
+    const t = await getTranslations("loading")
+    return <LoadingPageBase state="loading" props={{ message: t("message") }} on={{}} />
+}

package/templates/fe/skeleton/apps/__app__/src/features/pages/NotFoundPage/component.tsx

@@ -0,0 +1,32 @@
+import { GrammarRoot, Heading, PageContainer, TextAction, WorkspaceShell } from "@starci/grammar/common"
+import { ROUTES } from "@/modules/routes"
+
+/** Props for {@link NotFoundPageBase}. */
+export type NotFoundPageBaseProps = {
+    /** Whole-screen situations this surface settles; the not-found page only ever says the page is missing. */
+    readonly state: "missing"
+    /** The words the page shows. */
+    readonly props: {
+        readonly title: string
+        readonly homeLabel: string
+    }
+    /** What the surface reports upward; the page reports nothing. */
+    readonly on: Record<never, never>
+}
+
+/** Draw the missing-page message and the way back to the front door. */
+export const NotFoundPageBase = (props: NotFoundPageBaseProps) => (
+    <GrammarRoot>
+        <WorkspaceShell
+            primaryLabel={props.props.title}
+            primary={
+                <PageContainer measure="reading">
+                    <Heading level={1}>{props.props.title}</Heading>
+                    <TextAction appearance="inline" href={ROUTES.home}>
+                        {props.props.homeLabel}
+                    </TextAction>
+                </PageContainer>
+            }
+        />
+    </GrammarRoot>
+)

package/templates/fe/skeleton/apps/__app__/src/features/pages/NotFoundPage/index.tsx

@@ -0,0 +1,8 @@
+import { getTranslations } from "next-intl/server"
+import { NotFoundPageBase } from "./component"
+
+/** Shown when a route calls `notFound()`. */
+export const NotFoundPage = async () => {
+    const t = await getTranslations("notFound")
+    return <NotFoundPageBase state="missing" props={{ title: t("title"), homeLabel: t("home") }} on={{}} />
+}

package/templates/fe/skeleton/apps/__app__/src/modules/config/index.ts

@@ -0,0 +1,12 @@
+/**
+ * The only reader of `process.env` in this app. A value is read when it is asked for, not when the file loads, and a
+ * missing value stops the caller with a named error: there is no localhost fallback.
+ */
+
+const required = (name: string, value: string | undefined): string => {
+    if (value === undefined || value === "") throw new Error(`${name} is not set`)
+    return value
+}
+
+/** The public origin of the app, the base of every absolute metadata URL; throws when `NEXT_PUBLIC_SITE_URL` is not set. */
+export const siteUrl = (): string => required("NEXT_PUBLIC_SITE_URL", process.env.NEXT_PUBLIC_SITE_URL)

package/templates/fe/skeleton/apps/__app__/src/modules/i18n/index.ts

@@ -0,0 +1,2 @@
+export { DEFAULT_LOCALE } from "./config"
+export { routing } from "./routing"

package/templates/fe/skeleton/apps/__app__/src/modules/i18n/messages/vi.json

@@ -1,7 +1,13 @@
 {
+  "app": {
+    "title": "{{project}}"
+  },
   "home": {
     "title": "Trang chủ"
   },
+  "loading": {
+    "message": "Đang tải"
+  },
   "notFound": {
     "title": "Không tìm thấy trang",
     "home": "Về trang chủ"

package/templates/fe/{skeleton-app → skeleton}/apps/__app__/src/modules/i18n/request.ts

@@ -1,3 +1,4 @@
+import "server-only"
 import { hasLocale } from "next-intl"
 import { getRequestConfig } from "next-intl/server"
 import { routing } from "./routing"

package/templates/fe/skeleton/apps/__app__/src/modules/routes/index.ts

@@ -0,0 +1,4 @@
+/** Every internal destination the screens link to, named once. */
+export const ROUTES = {
+    home: "/",
+} as const

package/templates/fe/{skeleton-app → skeleton}/apps/__app__/src/proxy.ts

@@ -1,5 +1,5 @@
 import createMiddleware from "next-intl/middleware"
-import { routing } from "./modules/i18n/routing"
+import { routing } from "./modules/i18n"
 
 /** Negotiates the locale and redirects; the default locale (vi) is served without a prefix. */
 export default createMiddleware(routing)

package/sync/skeleton.mjs

@@ -1,76 +0,0 @@
-// hfs sync --init: the first source tree of a new repository (entrypoint, platform config/logging/errors, the health
-// endpoint; for a front end the next-intl [locale] shell with vi default, as-needed prefix and proxy.ts).
-// Unlike the managed files it is written once and never overwritten: an existing file is skipped, so re-running --init
-// on a repository that already grew its own source changes nothing.
-//
-// A front end's skeleton is the templates/fe/skeleton tree (the app shell, common to every repository) plus ONE of two
-// trees for what a repository writes once: with one app the app keeps its own i18n stack and its own API client
-// (templates/fe/skeleton-app); with two or more apps the stack and the client are written once, as the packages
-// `packages/<project>-i18n` and `packages/<project>-api`, and each app keeps a thin adapter over them
-// (templates/fe/skeleton-shared). The choice is the number of apps in hfs.json, nothing else.
-import fs from 'node:fs';
-import path from 'node:path';
-import { TEMPLATES_DIR, SyncError, render, validateHfs } from './index.mjs';
-
-const APP_DIR = '__app__';
-const FAMILY_DIR = '__family__';
-/** The slots a multi-app front end must opt into in hfs.json before its shared packages are written. */
-export const SHARED_PACKAGE_SLOTS = Object.freeze(['fe.package.i18n', 'fe.package.api']);
-const pascal = name => name.split('-').map(part => part[0].toUpperCase() + part.slice(1)).join('');
-
-function listFiles(dir, base = dir) {
-  return fs.readdirSync(dir, { withFileTypes: true }).flatMap(entry => {
-    const full = path.join(dir, entry.name);
-    return entry.isDirectory() ? listFiles(full, base) : [path.relative(base, full).split(path.sep).join('/')];
-  });
-}
-
-/** The apps that get a skeleton: a back end's `api` apps, every front-end app. */
-export const skeletonApps = hfs => hfs.apps.filter(app => hfs.profile === 'fe' || app.kind === 'api');
-
-/** True when the repository writes its i18n stack and API client once, as packages: a front end with two or more apps. */
-export const sharesPackages = hfs => hfs.profile === 'fe' && hfs.apps.length > 1;
-
-/** The template directories of a repository, in order: the profile's skeleton, then (front end) the one-app or the shared-package tree. */
-export const skeletonDirs = hfs => [path.join(TEMPLATES_DIR, hfs.profile, 'skeleton'), ...(hfs.profile === 'fe' ? [path.join(TEMPLATES_DIR, 'fe', sharesPackages(hfs) ? 'skeleton-shared' : 'skeleton-app')] : [])];
-
-/** Every skeleton file for this repository: [{ path, content }], the shared ones once and the per-app ones per app. */
-export function skeletonFiles(hfs, dirs = skeletonDirs(hfs)) {
-  validateHfs(hfs);
-  if (sharesPackages(hfs)) {
-    const missing = SHARED_PACKAGE_SLOTS.filter(id => !(hfs.optionalSlots ?? []).includes(id));
-    if (missing.length) throw new SyncError('HFS_SYNC_HFS_INVALID', `a front end with ${hfs.apps.length} apps writes its i18n stack and its API client once, as packages: list ${missing.join(' and ')} in hfs.json optionalSlots before hfs sync --init`);
-  }
-  const files = [];
-  for (const dir of dirs) {
-    if (!fs.existsSync(dir)) throw new SyncError('HFS_SYNC_SKELETON_MISSING', `no skeleton templates in ${path.relative(TEMPLATES_DIR, dir)}`);
-    for (const rel of listFiles(dir)) {
-      const source = fs.readFileSync(path.join(dir, rel), 'utf8').replace(/\r\n/g, '\n');
-      const once = { family: hfs.project, project: hfs.project };
-      if (!rel.includes(APP_DIR)) {
-        files.push({ path: rel.split(FAMILY_DIR).join(hfs.project), content: render(source, once) });
-        continue;
-      }
-      for (const app of skeletonApps(hfs)) {
-        files.push({ path: rel.split(APP_DIR).join(app.name), content: render(source, { ...once, app: app.name, appPascal: pascal(app.name) }) });
-      }
-    }
-  }
-  return files;
-}
-
-/** Writes the skeleton under `root`, skipping every file that exists: { created, skipped } path lists. */
-export function initSkeleton(root, hfs) {
-  const created = [], skipped = [];
-  for (const file of skeletonFiles(hfs)) {
-    const target = path.join(root, file.path);
-    if (fs.existsSync(target)) {
-      skipped.push(file.path);
-      continue;
-    }
-    fs.mkdirSync(path.dirname(target), { recursive: true });
-    fs.writeFileSync(target, file.content);
-    created.push(file.path);
-  }
-  return { created, skipped };
-}

package/templates/be/gitignore

@@ -1,2 +0,0 @@
-{{> common/gitignore.base}}
-schema.gql

package/templates/be/hooks/husky/pre-commit

@@ -1,13 +0,0 @@
-{{header}}
-# Commit gate: the secrets guard and work hygiene of the staged files, types, lint and format of the staged files, the unit specs the staged files touch. Never integration, e2e or contract.
-npx hfs work-hygiene
-npm run typecheck
-sources=$(git diff --cached --name-only --diff-filter=ACMR -- '*.ts' '*.mts' '*.cts' '*.js' '*.mjs' '*.cjs' || true)
-if [ -n "$sources" ]; then
-  npx eslint $sources
-  npx prettier --check $sources
-fi
-specs=$(git diff --cached --name-only --diff-filter=ACMR -- '*.ts' | grep -v -E '(^|/)src/tests/(world|integration|e2e|contract)/|\.(integration|e2e|contract)-spec\.ts$' || true)
-if [ -n "$specs" ]; then
-  npm run test:affected -- --findRelatedTests $specs
-fi

package/templates/be/hooks/husky/pre-push

@@ -1,6 +0,0 @@
-{{header}}
-# Push gate: types, lint, format, unit specs affected since main. Never integration, e2e or contract.
-npm run typecheck
-npm run lint
-npm run format:check
-npm run test:affected -- --changedSince=origin/main

package/templates/be/package-scripts/package.json

@@ -1,19 +0,0 @@
-{
-  "scripts": {
-    "build": "tsc -p tsconfig.build.json && tsc-alias -p tsconfig.build.json",
-    {{appScripts}}
-    "typecheck": "tsc -p tsconfig.json",
-    "typecheck:tests": "tsc -p src/tests/tsconfig.json",
-    "lint": "hfs lint",
-    "lint:fix": "hfs lint --fix",
-    "format": "prettier --write .",
-    "format:check": "prettier --check .",
-    "test": "jest --selectProjects unit --coverage",
-    "test:affected": "jest --selectProjects unit --passWithNoTests",
-    "test:integration": "npm run typecheck:tests && jest --selectProjects integration",
-    "test:e2e": "npm run typecheck:tests && jest --selectProjects e2e",
-    "test:contract": "npm run typecheck:tests && jest --selectProjects contract",
-    "test:stack": "starci-test-stack",
-    "contract:emit": "hfs emit-contracts"
-  }
-}

package/templates/be/skeleton/src/modules/platform/config/config.decorators.ts

@@ -1,9 +0,0 @@
-import { injector } from "@modules/platform/composition"
-import type { TypedParameterDecorator } from "@modules/platform/composition"
-import type { ServerOptions } from "./server.options"
-
-/** Token under which the app module provides its {@link ServerOptions}. */
-export const SERVER_OPTIONS: unique symbol = Symbol("platform.config.server-options")
-
-/** Injects the server options of the app. Parameter type: ServerOptions. */
-export const InjectServerOptions = (): TypedParameterDecorator<ServerOptions> => injector<ServerOptions>(SERVER_OPTIONS)

package/templates/be/skeleton/src/modules/platform/errors/error.filter.ts

@@ -1,20 +0,0 @@
-import { Catch, HttpException, HttpStatus } from "@nestjs/common"
-import type { ArgumentsHost, ExceptionFilter } from "@nestjs/common"
-import type { Response } from "express"
-import { InjectLogger } from "@modules/platform/logging"
-import type { Logger } from "@modules/platform/logging"
-import { ErrorsLogEvent } from "./errors.log-events"
-
-@Catch()
-/** The one filter of an app: logs every failure once and answers with a status and a code that reveal nothing else. */
-export class ErrorFilter implements ExceptionFilter {
-    constructor(@InjectLogger() private readonly logger: Logger) {}
-
-    /** Answers the request; an unknown failure is a 500 whose body names no detail. */
-    catch(exception: unknown, host: ArgumentsHost): void {
-        const status = exception instanceof HttpException ? exception.getStatus() : HttpStatus.INTERNAL_SERVER_ERROR
-        this.logger.error(ErrorsLogEvent.RequestFailed, exception, { status })
-        const code = status === HttpStatus.INTERNAL_SERVER_ERROR ? "internal_error" : `http_${status}`
-        host.switchToHttp().getResponse<Response>().status(status).json({ code })
-    }
-}

package/templates/be/tool-config/prettierignore

@@ -1,8 +0,0 @@
-{{header}}
-dist/
-coverage/
-node_modules/
-package-lock.json
-contracts/
-.starcistacks/
-.starciwork/

package/templates/fe/ci-workflows/github/workflows/ci.yml

@@ -1,40 +0,0 @@
-{{header}}
-name: ci
-
-on:
-  push:
-    branches: [main]
-  pull_request:
-
-permissions:
-  contents: read
-
-jobs:
-  ci:
-    runs-on: ubuntu-latest
-    env:
-      SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v4
-        with:
-          node-version: {{nodeMajor}}
-          cache: npm
-      - run: npm ci
-      - name: lint
-        run: npm run lint -- --sonar reports/lint.sonar.json
-      - name: format
-        run: npm run format:check
-      - name: typecheck
-        run: npm run typecheck
-      - name: build
-        run: npm run build
-      - uses: SonarSource/sonarqube-scan-action@v7
-        if: ${{ !cancelled() && env.SONAR_TOKEN != '' }}
-        env:
-          SONAR_HOST_URL: ${{ vars.SONAR_HOST_URL }}
-      - uses: SonarSource/sonarqube-quality-gate-action@v1
-        if: ${{ !cancelled() && env.SONAR_TOKEN != '' }}
-        timeout-minutes: 10
-        env:
-          SONAR_HOST_URL: ${{ vars.SONAR_HOST_URL }}

package/templates/fe/gitignore

@@ -1,3 +0,0 @@
-{{> common/gitignore.base}}
-.next/
-next-env.d.ts

package/templates/fe/hooks/husky/pre-commit

@@ -1,16 +0,0 @@
-{{header}}
-# Commit gate: the secrets guard, then types, lint and format of the staged files.
-npx hfs work-hygiene
-npm run typecheck
-sources=$(git diff --cached --name-only --diff-filter=ACMR -- '*.ts' '*.tsx' '*.mts' '*.cts' '*.js' '*.jsx' '*.mjs' '*.cjs' || true)
-if [ -n "$sources" ]; then
-  npx eslint --max-warnings=0 --no-warn-ignored $sources
-fi
-styles=$(git diff --cached --name-only --diff-filter=ACMR -- '*.css' || true)
-if [ -n "$styles" ]; then
-  npx stylelint $styles
-fi
-formatted=$(git diff --cached --name-only --diff-filter=ACMR || true)
-if [ -n "$formatted" ]; then
-  npx prettier --check --ignore-unknown $formatted
-fi

package/templates/fe/hooks/husky/pre-push

@@ -1,5 +0,0 @@
-{{header}}
-# Push gate: types, lint (eslint over the repository, stylelint over the CSS), format; one `hfs lint` runs eslint, the repository check and stylelint.
-npm run typecheck
-npm run lint
-npm run format:check

package/templates/fe/package-scripts/package.json

@@ -1,13 +0,0 @@
-{
-  "scripts": {
-    "prepare": "husky",
-    {{appScripts}}
-    "codegen": "npm run codegen --workspaces --if-present",
-    "build": "npm run build --workspaces --if-present",
-    "typecheck": "npm run typecheck --workspaces --if-present",
-    "lint": "npm run codegen --silent && hfs lint --stylelint \"{{styleGlob}}\"",
-    "lint:fix": "npm run codegen --silent && hfs lint --fix --stylelint \"{{styleGlob}}\"",
-    "format": "prettier --write .",
-    "format:check": "prettier --check ."
-  }
-}

package/templates/fe/parts/api-client.ts

@@ -1,44 +0,0 @@
-import type { Outcome } from "./outcome"
-
-/** How long a request waits before it is abandoned and answered `unavailable`. */
-const REQUEST_TIMEOUT_MS = 8000
-
-/** One request of the client: the caller's own signal is joined with the timeout. */
-export interface ClientRequest {
-    readonly url: string
-    readonly method?: "GET" | "POST" | "PUT" | "PATCH" | "DELETE"
-    readonly body?: unknown
-    readonly signal?: AbortSignal
-}
-
-/** The status of a response as an Outcome kind; 401 and 403 are `refused`, nothing collapses into `null`. */
-const toOutcome = async (response: Response): Promise<Outcome<unknown>> => {
-    if (response.status === 401 || response.status === 403) return { kind: "refused" }
-    if (response.status === 404) return { kind: "not-found" }
-    if (response.status === 400 || response.status === 422) return { kind: "invalid" }
-    if (!response.ok) return { kind: "unavailable" }
-    try {
-        return { kind: "ok", data: (await response.json()) as unknown }
-    } catch {
-        return { kind: "unavailable" }
-    }
-}
-
-/**
- * The repository's one fetch. It always carries a timeout signal, never throws, and answers an Outcome; the body is
- * `unknown` until a generated wire type narrows it.
- */
-export const request = async ({ url, method = "GET", body, signal }: ClientRequest): Promise<Outcome<unknown>> => {
-    const timeout = AbortSignal.timeout(REQUEST_TIMEOUT_MS)
-    try {
-        const response = await fetch(url, {
-            method,
-            headers: { accept: "application/json", ...(body === undefined ? {} : { "content-type": "application/json" }) },
-            ...(body === undefined ? {} : { body: JSON.stringify(body) }),
-            signal: signal === undefined ? timeout : AbortSignal.any([signal, timeout]),
-        })
-        return await toOutcome(response)
-    } catch {
-        return { kind: "unavailable" }
-    }
-}

package/templates/fe/parts/api-outcome.ts

@@ -1,7 +0,0 @@
-/** The one result every read of the backend returns: a status is a kind, never a thrown error and never `null`. */
-export type Outcome<T> =
-    | { readonly kind: "ok"; readonly data: T }
-    | { readonly kind: "refused" }
-    | { readonly kind: "invalid" }
-    | { readonly kind: "not-found" }
-    | { readonly kind: "unavailable" }