@moifort/stack 0.0.0-stage → 0.1.0

package/templates/ios/ios/{{APP_NAME}}/PrivacyInfo.xcprivacy

@@ -0,0 +1,122 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<!-- Nothing here follows the user across other companies' apps or websites:
+	     no advertising identifier, no ad SDK, no data broker. -->
+	<key>NSPrivacyTracking</key>
+	<false/>
+	<key>NSPrivacyTrackingDomains</key>
+	<array/>
+	<key>NSPrivacyCollectedDataTypes</key>
+	<array>
+		<!-- Which screens are reached and which milestones are crossed, read as
+		     aggregates to know where people give up. -->
+		<dict>
+			<key>NSPrivacyCollectedDataType</key>
+			<string>NSPrivacyCollectedDataTypeProductInteraction</string>
+			<key>NSPrivacyCollectedDataTypeLinked</key>
+			<true/>
+			<key>NSPrivacyCollectedDataTypeTracking</key>
+			<false/>
+			<key>NSPrivacyCollectedDataTypePurposes</key>
+			<array>
+				<string>NSPrivacyCollectedDataTypePurposeAnalytics</string>
+			</array>
+		</dict>
+		<!-- The identifier the analytics SDK gives the install, which is what makes
+		     one session distinguishable from another. -->
+		<dict>
+			<key>NSPrivacyCollectedDataType</key>
+			<string>NSPrivacyCollectedDataTypeDeviceID</string>
+			<key>NSPrivacyCollectedDataTypeLinked</key>
+			<true/>
+			<key>NSPrivacyCollectedDataTypeTracking</key>
+			<false/>
+			<key>NSPrivacyCollectedDataTypePurposes</key>
+			<array>
+				<string>NSPrivacyCollectedDataTypePurposeAnalytics</string>
+			</array>
+		</dict>
+		<!-- Crashes and errors, so a bug is fixed before it is reported. -->
+		<dict>
+			<key>NSPrivacyCollectedDataType</key>
+			<string>NSPrivacyCollectedDataTypeCrashData</string>
+			<key>NSPrivacyCollectedDataTypeLinked</key>
+			<false/>
+			<key>NSPrivacyCollectedDataTypeTracking</key>
+			<false/>
+			<key>NSPrivacyCollectedDataTypePurposes</key>
+			<array>
+				<string>NSPrivacyCollectedDataTypePurposeAppFunctionality</string>
+			</array>
+		</dict>
+		<!-- How long a screen took to answer, sampled: the same reports, on the
+		     requests that did not fail. -->
+		<dict>
+			<key>NSPrivacyCollectedDataType</key>
+			<string>NSPrivacyCollectedDataTypePerformanceData</string>
+			<key>NSPrivacyCollectedDataTypeLinked</key>
+			<false/>
+			<key>NSPrivacyCollectedDataTypeTracking</key>
+			<false/>
+			<key>NSPrivacyCollectedDataTypePurposes</key>
+			<array>
+				<string>NSPrivacyCollectedDataTypePurposeAppFunctionality</string>
+			</array>
+		</dict>
+		<!-- The account itself: a Sign in with Apple identifier and the first name
+		     the onboarding asks for, without which there is no account. -->
+		<dict>
+			<key>NSPrivacyCollectedDataType</key>
+			<string>NSPrivacyCollectedDataTypeUserID</string>
+			<key>NSPrivacyCollectedDataTypeLinked</key>
+			<true/>
+			<key>NSPrivacyCollectedDataTypeTracking</key>
+			<false/>
+			<key>NSPrivacyCollectedDataTypePurposes</key>
+			<array>
+				<string>NSPrivacyCollectedDataTypePurposeAppFunctionality</string>
+			</array>
+		</dict>
+		<dict>
+			<key>NSPrivacyCollectedDataType</key>
+			<string>NSPrivacyCollectedDataTypeName</string>
+			<key>NSPrivacyCollectedDataTypeLinked</key>
+			<true/>
+			<key>NSPrivacyCollectedDataTypeTracking</key>
+			<false/>
+			<key>NSPrivacyCollectedDataTypePurposes</key>
+			<array>
+				<string>NSPrivacyCollectedDataTypePurposeAppFunctionality</string>
+			</array>
+		</dict>
+		<!-- The address Sign in with Apple hands back, which is the account. -->
+		<dict>
+			<key>NSPrivacyCollectedDataType</key>
+			<string>NSPrivacyCollectedDataTypeEmailAddress</string>
+			<key>NSPrivacyCollectedDataTypeLinked</key>
+			<true/>
+			<key>NSPrivacyCollectedDataTypeTracking</key>
+			<false/>
+			<key>NSPrivacyCollectedDataTypePurposes</key>
+			<array>
+				<string>NSPrivacyCollectedDataTypePurposeAppFunctionality</string>
+			</array>
+		</dict>
+		
+	</array>
+	<key>NSPrivacyAccessedAPITypes</key>
+	<array>
+		<!-- UserDefaults: the server URL for a test run. -->
+		<dict>
+			<key>NSPrivacyAccessedAPIType</key>
+			<string>NSPrivacyAccessedAPICategoryUserDefaults</string>
+			<key>NSPrivacyAccessedAPITypeReasons</key>
+			<array>
+				<string>CA92.1</string>
+			</array>
+		</dict>
+	</array>
+</dict>
+</plist>

package/templates/ios/ios/{{APP_NAME}}/Shared/APIClient.swift

@@ -0,0 +1,23 @@
+import Foundation
+
+/// Resolves the Cloud Function that hosts the GraphQL API. All HTTP transport
+/// happens through GraphQLClient (Apollo iOS).
+///
+/// `serverURL` in the app's defaults overrides it, for a run against the local
+/// server or the staging project:
+/// `xcrun simctl spawn <udid> defaults write {{BUNDLE_ID}} serverURL http://localhost:3000`.
+struct APIClient: Sendable {
+    static let shared = APIClient()
+
+    private static let serverURLKey = "serverURL"
+    // The deployed Cloud Function, written here once the first deploy printed it.
+    // A wrong value does not fail loudly: any *.a.run.app host resolves, so the
+    // app reaches Google and gets a 404 that reads like a broken API.
+    private static let defaultServerURL = "{{SERVER_URL}}"
+
+    var baseURL: URL {
+        let stored = UserDefaults.standard.string(forKey: Self.serverURLKey)
+            ?? Self.defaultServerURL
+        return URL(string: stored) ?? URL(string: Self.defaultServerURL)!
+    }
+}

package/templates/ios/ios/{{APP_NAME}}/Shared/AcceptLanguageInterceptor.swift

@@ -0,0 +1,20 @@
+import Apollo
+import Foundation
+
+/// Sends the language the app is shown in as `Accept-Language` on every GraphQL
+/// request. The backend uses it to write what it writes in the user's language. The app's language rather
+/// than the device's first one: a user whose iPhone is in German sees the app
+/// in English, and reads its summaries in English too. Runs at the HTTP layer
+/// where the request is a plain `URLRequest`.
+struct AcceptLanguageInterceptor: HTTPInterceptor {
+    func intercept(
+        request: URLRequest,
+        next: NextHTTPInterceptorFunction
+    ) async throws -> HTTPResponse {
+        var request = request
+        if let preferred = Bundle.main.preferredLocalizations.first ?? Locale.preferredLanguages.first {
+            request.setValue(preferred, forHTTPHeaderField: "Accept-Language")
+        }
+        return try await next(request)
+    }
+}

package/templates/ios/ios/{{APP_NAME}}/Shared/Components/atoms/AsyncButton.swift

@@ -0,0 +1,73 @@
+import SwiftUI
+
+/// A button whose action takes time on the network: it shows a spinner in place
+/// of its label from the tap until the call settles, and refuses a second tap
+/// meanwhile. Every call to action that waits on a server goes through this or
+/// its toolbar sibling, so no tap is ever answered by nothing.
+///
+/// The label keeps its width while the spinner shows, so a row of buttons does
+/// not shuffle when one of them is working.
+struct AsyncButton<Label: View>: View {
+    var role: ButtonRole? = nil
+    let action: () async -> Void
+    @ViewBuilder let label: () -> Label
+
+    @State private var isInProgress = false
+
+    init(
+        role: ButtonRole? = nil,
+        action: @escaping () async -> Void,
+        @ViewBuilder label: @escaping () -> Label
+    ) {
+        self.role = role
+        self.action = action
+        self.label = label
+    }
+
+    var body: some View {
+        Button(role: role) {
+            guard !isInProgress else { return }
+            isInProgress = true
+            Task {
+                await action()
+                isInProgress = false
+            }
+        } label: {
+            ZStack {
+                label().opacity(isInProgress ? 0 : 1)
+                if isInProgress {
+                    ProgressView()
+                }
+            }
+        }
+        .disabled(isInProgress)
+    }
+}
+
+extension AsyncButton where Label == Text {
+    init(_ title: LocalizedStringKey, role: ButtonRole? = nil, action: @escaping () async -> Void) {
+        self.init(role: role, action: action) { Text(title) }
+    }
+}
+
+extension AsyncButton where Label == SwiftUI.Label<Text, Image> {
+    init(
+        _ title: LocalizedStringKey,
+        systemImage: String,
+        role: ButtonRole? = nil,
+        action: @escaping () async -> Void
+    ) {
+        self.init(role: role, action: action) { SwiftUI.Label(title, systemImage: systemImage) }
+    }
+}
+
+#Preview {
+    VStack(spacing: 16) {
+        AsyncButton("Réessayer") { try? await Task.sleep(for: .seconds(2)) }
+        AsyncButton("Synchroniser", systemImage: "arrow.triangle.2.circlepath") {
+            try? await Task.sleep(for: .seconds(2))
+        }
+        .buttonStyle(.borderedProminent)
+    }
+    .padding()
+}

package/templates/ios/ios/{{APP_NAME}}/Shared/Components/atoms/AsyncToolbarButton.swift

@@ -0,0 +1,69 @@
+import SwiftUI
+
+struct AsyncToolbarButton: View {
+    let title: LocalizedStringKey
+    let systemImage: String
+    var role: ButtonRole? = nil
+    let action: () async -> Void
+
+    @State private var isInProgress = false
+
+    var body: some View {
+        Button(role: role) {
+            guard !isInProgress else { return }
+            isInProgress = true
+            Task {
+                await action()
+                isInProgress = false
+            }
+        } label: {
+            if isInProgress {
+                ProgressView()
+            } else {
+                Label(title, systemImage: systemImage)
+            }
+        }
+        .labelStyle(.iconOnly)
+        .disabled(isInProgress)
+    }
+}
+
+#Preview("Idle") {
+    NavigationStack {
+        Text("Contenu")
+            .toolbar {
+                ToolbarItem(placement: .confirmationAction) {
+                    AsyncToolbarButton(title: "Enregistrer", systemImage: "checkmark") {}
+                }
+            }
+    }
+}
+
+#Preview("In progress") {
+    NavigationStack {
+        Text("Contenu")
+            .toolbar {
+                ToolbarItem(placement: .confirmationAction) {
+                    // A long action keeps the spinner on screen in the canvas.
+                    AsyncToolbarButton(title: "Enregistrer", systemImage: "checkmark") {
+                        try? await Task.sleep(for: .seconds(60))
+                    }
+                }
+            }
+    }
+}
+
+#Preview("Destructive") {
+    NavigationStack {
+        Text("Contenu")
+            .toolbar {
+                ToolbarItem(placement: .destructiveAction) {
+                    AsyncToolbarButton(
+                        title: "Supprimer",
+                        systemImage: "trash",
+                        role: .destructive
+                    ) {}
+                }
+            }
+    }
+}

package/templates/ios/ios/{{APP_NAME}}/Shared/Components/atoms/ToolbarIconButton.swift

@@ -0,0 +1,46 @@
+import SwiftUI
+
+/// Icon-only toolbar button. The `title` is kept purely for accessibility (VoiceOver);
+/// only the SF Symbol is rendered. Used for cancel / close / back and secondary actions.
+struct ToolbarIconButton: View {
+    let title: LocalizedStringKey
+    let systemImage: String
+    var role: ButtonRole? = nil
+    let action: () -> Void
+
+    var body: some View {
+        Button(role: role, action: action) {
+            Label(title, systemImage: systemImage)
+        }
+        .labelStyle(.iconOnly)
+    }
+}
+
+#Preview("Close and confirm") {
+    NavigationStack {
+        Text("Contenu")
+            .toolbar {
+                ToolbarItem(placement: .cancellationAction) {
+                    ToolbarIconButton(title: "Fermer", systemImage: "xmark", role: .cancel) {}
+                }
+                ToolbarItem(placement: .confirmationAction) {
+                    ToolbarIconButton(title: "Enregistrer", systemImage: "checkmark") {}
+                }
+            }
+    }
+}
+
+#Preview("Destructive") {
+    NavigationStack {
+        Text("Contenu")
+            .toolbar {
+                ToolbarItem(placement: .destructiveAction) {
+                    ToolbarIconButton(
+                        title: "Supprimer",
+                        systemImage: "trash",
+                        role: .destructive
+                    ) {}
+                }
+            }
+    }
+}

package/templates/ios/ios/{{APP_NAME}}/Shared/Components/molecules/EmptyState.swift

@@ -0,0 +1,132 @@
+import SwiftUI
+
+/// The one empty state of the app: an icon, a title, one sentence, and one
+/// prominent button, the action that fills the list. A second, plainer button
+/// exists for the rare screen that needs it. Every list draws its emptiness with
+/// it, so a user meets the same shape wherever there is nothing to show yet.
+///
+/// `failure` is the same shape for a list that could not load: the reason in
+/// the sentence, "Réessayer" as the button.
+struct EmptyState: View {
+    let systemImage: String
+    let title: LocalizedStringKey
+    let message: Text
+    var primary: Action?
+    var secondary: Action?
+    /// A symbol of the asset catalog drawn in place of `systemImage`: one of
+    /// the app's own, made by `ios/tools/generate-symbols.swift`.
+    private var assetSymbol: String?
+
+    /// A button of the empty state. Async so that a retry can show it is
+    /// running rather than being tapped again.
+    struct Action {
+        let title: LocalizedStringKey
+        var systemImage: String?
+        let run: () async -> Void
+
+        init(_ title: LocalizedStringKey, systemImage: String? = nil, run: @escaping () async -> Void) {
+            self.title = title
+            self.systemImage = systemImage
+            self.run = run
+        }
+    }
+
+    init(
+        systemImage: String,
+        title: LocalizedStringKey,
+        message: LocalizedStringKey,
+        primary: Action? = nil,
+        secondary: Action? = nil
+    ) {
+        self.systemImage = systemImage
+        self.title = title
+        self.message = Text(message)
+        self.primary = primary
+        self.secondary = secondary
+    }
+
+    /// For a sentence built at run time — an error, a friend's name.
+    init(
+        systemImage: String,
+        title: LocalizedStringKey,
+        verbatim message: String,
+        primary: Action? = nil,
+        secondary: Action? = nil
+    ) {
+        self.systemImage = systemImage
+        self.title = title
+        self.message = Text(verbatim: message)
+        self.primary = primary
+        self.secondary = secondary
+    }
+
+    /// A list that could not load: what failed, and a retry.
+    static func failure(
+        _ title: LocalizedStringKey,
+        message: String,
+        retry: @escaping () async -> Void
+    ) -> EmptyState {
+        EmptyState(
+            systemImage: "wifi.exclamationmark",
+            title: title,
+            verbatim: message,
+            primary: Action("Réessayer", systemImage: "arrow.clockwise", run: retry)
+        )
+    }
+
+    var body: some View {
+        ContentUnavailableView {
+            if let assetSymbol {
+                Label(title, image: assetSymbol)
+            } else {
+                Label(title, systemImage: systemImage)
+            }
+        } description: {
+            message
+        } actions: {
+            if let primary {
+                AsyncButton {
+                    await primary.run()
+                } label: {
+                    label(of: primary)
+                }
+                .buttonStyle(.borderedProminent)
+                .accessibilityIdentifier("empty-primary")
+            }
+            if let secondary {
+                AsyncButton {
+                    await secondary.run()
+                } label: {
+                    label(of: secondary)
+                }
+                .buttonStyle(.bordered)
+                .accessibilityIdentifier("empty-secondary")
+            }
+        }
+    }
+
+    /// The same state, drawn with one of the app's own symbols.
+    func assetSymbol(_ name: String) -> EmptyState {
+        var drawn = self
+        drawn.assetSymbol = name
+        return drawn
+    }
+
+    @ViewBuilder
+    private func label(of action: Action) -> some View {
+        if let systemImage = action.systemImage {
+            Label(action.title, systemImage: systemImage)
+        } else {
+            Text(action.title)
+        }
+    }
+}
+
+#Preview {
+    EmptyState(
+        systemImage: "tray",
+        title: "Rien pour l'instant",
+        message: "Ajoutez un premier élément pour commencer.",
+        primary: .init("Ajouter", systemImage: "plus") {}
+    )
+}

package/templates/ios/ios/{{APP_NAME}}/Shared/Components/molecules/LabeledInfoRow.swift

@@ -0,0 +1,29 @@
+import SwiftUI
+
+struct LabeledInfoRow: View {
+    let title: LocalizedStringKey
+    let value: String
+    let icon: String
+
+    var body: some View {
+        Label {
+            LabeledContent {
+                Text(value)
+            } label: {
+                Text(title)
+            }
+        } icon: {
+            Image(systemName: icon)
+                .foregroundStyle(.secondary)
+        }
+        // Every fact a sheet states can be taken elsewhere with a long press.
+        .copyable(value)
+    }
+}
+
+#Preview {
+    List {
+        LabeledInfoRow(title: "Prénom", value: "Ada", icon: "person")
+        LabeledInfoRow(title: "Ville", value: "Lyon", icon: "map")
+    }
+}

package/templates/ios/ios/{{APP_NAME}}/Shared/Components/styles/CaptionLabelStyle.swift

@@ -0,0 +1,45 @@
+import SwiftUI
+
+/// A label sized for a caption: a small glyph in a narrow column of fixed width,
+/// so that two of them stacked keep their words on the same left edge whatever
+/// the glyphs' own widths. For text that sits inside a row rather than being the
+/// row — beside a cover, under a title — where a list's default label style would
+/// hand each icon the wide, centred column meant for a row of its own.
+struct CaptionLabelStyle: LabelStyle {
+    func makeBody(configuration: Configuration) -> some View {
+        CaptionLabel(configuration: configuration)
+    }
+}
+
+/// The style's body, a view of its own for the scaled column: a fixed 14 points
+/// held at the larger text sizes while the glyph grew, which then spilled over
+/// its words.
+private struct CaptionLabel: View {
+    let configuration: LabelStyleConfiguration
+    @ScaledMetric(relativeTo: .caption) private var iconWidth: CGFloat = 14
+
+    var body: some View {
+        HStack(alignment: .firstTextBaseline, spacing: 4) {
+            configuration.icon
+                .imageScale(.small)
+                .frame(width: iconWidth)
+            configuration.title
+        }
+    }
+}
+
+extension LabelStyle where Self == CaptionLabelStyle {
+    static var caption: CaptionLabelStyle { CaptionLabelStyle() }
+}
+
+#Preview {
+    List {
+        VStack(alignment: .leading, spacing: 2) {
+            Label("Mis à jour hier", systemImage: "clock.arrow.circlepath")
+            Label("Lyon", systemImage: "mappin")
+        }
+        .labelStyle(.caption)
+        .font(.caption)
+        .foregroundStyle(.secondary)
+    }
+}

package/templates/ios/ios/{{APP_NAME}}/Shared/Components/styles/Copyable.swift

@@ -0,0 +1,32 @@
+import SwiftUI
+import UIKit
+
+/// One piece of text a long press offers to copy, with the words its menu item
+/// says it under.
+struct CopyableValue {
+    let title: LocalizedStringKey
+    let value: String
+}
+
+extension View {
+    /// A long press offers to copy `value`: an ISBN to paste in a bookshop, a
+    /// title to search for. A context menu rather than selectable text, which a
+    /// list row does not offer and a button row would swallow.
+    func copyable(_ value: String) -> some View {
+        copyable([CopyableValue(title: "Copier", value: value)])
+    }
+
+    /// The same for a row that holds several values — a title and its author
+    /// side by side: one menu item each, and none for a value left empty.
+    func copyable(_ values: [CopyableValue]) -> some View {
+        contextMenu {
+            ForEach(Array(values.enumerated()), id: \.offset) { _, entry in
+                if !entry.value.isEmpty {
+                    Button(entry.title, systemImage: "doc.on.doc") {
+                        UIPasteboard.general.string = entry.value
+                    }
+                }
+            }
+        }
+    }
+}

package/templates/ios/ios/{{APP_NAME}}/Shared/Components/styles/EdgeToEdgeSeparator.swift

@@ -0,0 +1,14 @@
+import SwiftUI
+
+extension View {
+    /// A list row whose separator runs from one edge of the card to the other,
+    /// rather than starting at the text: the inset is pinned rather than left
+    /// to the list, so the guides know exactly how far the edges are. Put on
+    /// the outermost view of the row — a book row followed by a button would
+    /// otherwise stop its line short of the button.
+    func edgeToEdgeSeparator(inset: CGFloat = 16) -> some View {
+        listRowInsets(.horizontal, inset)
+            .alignmentGuide(.listRowSeparatorLeading) { $0[.leading] - inset }
+            .alignmentGuide(.listRowSeparatorTrailing) { $0[.trailing] + inset }
+    }
+}

package/templates/ios/ios/{{APP_NAME}}/Shared/Components/styles/RowLabelStyle.swift

@@ -0,0 +1,58 @@
+import SwiftUI
+
+/// The one way an icon sits beside a row's text, on every form and sheet of the
+/// app: in a column of fixed width, so glyphs of different widths still line
+/// their text up, and level with the first line of text rather than centred on
+/// the row, so a field that wraps onto three lines keeps its icon beside its
+/// title.
+///
+/// Applied per screen with `.labelStyle(.row)`, which every `Label` under it
+/// inherits — menu items are drawn by the system and keep their own layout.
+struct RowLabelStyle: LabelStyle {
+    func makeBody(configuration: Configuration) -> some View {
+        RowLabel(configuration: configuration)
+    }
+}
+
+/// The style's body, a view of its own for the scaled column: held at a fixed
+/// width while the glyph grew with the text, it pushed the icon out past the
+/// row's left edge at the larger sizes.
+private struct RowLabel: View {
+    let configuration: LabelStyleConfiguration
+    /// Wide enough for the widest symbol the rows use, at every text size.
+    @ScaledMetric(relativeTo: .body) private var iconWidth: CGFloat = 26
+
+    var body: some View {
+        HStack(alignment: .firstTextBaseline, spacing: 12) {
+            configuration.icon
+                .font(.body)
+                .imageScale(.medium)
+                // A floor, not a width: at the largest sizes the widest glyphs
+                // outgrow even the scaled column, and are better given room
+                // than pushed out of the row.
+                .frame(minWidth: iconWidth)
+            configuration.title
+        }
+    }
+}
+
+extension LabelStyle where Self == RowLabelStyle {
+    static var row: RowLabelStyle { RowLabelStyle() }
+}
+
+#Preview {
+    List {
+        Label("Ville", systemImage: "building.2")
+        Label("Prénom", systemImage: "person")
+        Label {
+            VStack(alignment: .leading, spacing: 6) {
+                Text("Note")
+                Text("Une note assez longue pour passer sur deux lignes et montrer où reste l'icône")
+                    .foregroundStyle(.secondary)
+            }
+        } icon: {
+            Image(systemName: "tag").foregroundStyle(.secondary)
+        }
+    }
+    .labelStyle(.row)
+}