lanework/Kanban/UI/Board/NewCardTarget.swift

/// 04-interactions.md's **⌘N target rule** (settled), as a pure function of the three things it
/// reads — the selection, the last-active lane, and the snapshot (`NewCardTargetTests`).
///
/// The rule verbatim, and each clause's branch below:
///
/// > with a card selected, the new card is created in that card's lane, immediately after it
/// > (paste-anchor consistency); with a lane selected, appended at its bottom (Return consistency);
/// > a multi-selection anchors at its last member in flatten order (lane `order`, then card
/// > `order`, the multi-drag order; the same anchor serves paste): creation follows the last
/// > selected card, or appends to the last selected lane; … with nothing selected — or a
/// > **tombstoned** selection, which never anchors creation — the **last-active lane** — the lane
/// > that most recently held selection or a creation in this window session — falling back to the
/// > first lane. … **Zero-lane board**: card creation … disable[s] via menu validation until a
/// > lane exists.
///
/// **A pure function rather than a method on the store** for the reason every rule in this codebase
/// that can be one is: the branches are lines of test rather than UI states to drive, and the menu
/// item's `disabled` and its action then read the *same* answer instead of two hand-kept-in-sync
/// conditions.
///
/// ### What it deliberately does not decide
///
/// - **The lane header's new-card button overrides this rule entirely** (11-command-nexus.md ▸
///   Pointer grammar, settled): "the click names its target lane, selection notwithstanding". That
///   call site passes its own lane and never comes here.
/// - **Return on a selected lane** is the same target as this rule's lane branch, but it is reached
///   by grammar rather than by the menu; it also passes its lane directly.
enum NewCardTarget {

    /// Where a new card goes: which lane, and which card it lands immediately after (`nil` = the
    /// lane's bottom). Exactly `NewCardPlaceholder`'s two anchoring fields, because that is what
    /// this resolves *into*.
    struct Resolution: Equatable {
        let laneID: ItemID
        let anchorCardID: ItemID?
    }

    /// The target, or `nil` when there is none — **the zero-lane board**, where "New Card,
    /// Return-creation, and Paste with a card payload disable via menu validation until a lane
    /// exists". `nil` is therefore the menu item's `disabled` condition as well as its refusal, so
    /// the two can never disagree.
    ///
    /// - Parameters:
    ///   - selection: the board's current selection, liveness side included. A `.trashed` selection
    ///     "never anchors creation" and is treated exactly as an empty one — the settled precedent
    ///     04 ▸ Clipboard cites for paste, applied here to its source rule ("a trashed card's live
    ///     disk-lane never leaks in as 'the selected card's lane'").
    ///   - lastActiveLaneID: `TransientBoardState.lastActiveLaneID`, already cleared by the reload
    ///     rule if its lane vanished — but re-checked here anyway, because a caller need not have
    ///     reloaded since the lane went.
    static func resolve(
        selection: ItemReferenceSet,
        lastActiveLaneID: ItemID?,
        snapshot: BoardModel
    ) -> Resolution? {
        let lanes = snapshot.lanes.filter { !$0.isDeleted }
        guard !lanes.isEmpty else { return nil }

        if selection.liveness == .live, !selection.ids.isEmpty {
            // The last selected member in flatten order — lane `order`, then card `order`, the
            // multi-drag order (04, settled; the same anchor serves paste). The snapshot's lanes
            // and cards are already in display order, so the flatten order is one walk, and the
            // *last* hit is the anchor. Selection is homogeneous (cards XOR lanes), so only one of
            // the two branches ever fires within a walk; a sole selection is simply the degenerate
            // one-member case of the same rule.
            var anchor: Resolution?
            for lane in lanes {
                // A selected lane: creation appends at its bottom, Return consistency.
                if selection.ids.contains(lane.id) {
                    anchor = Resolution(laneID: lane.id, anchorCardID: nil)
                }
                // A selected card: its lane, immediately after it — paste-anchor consistency.
                for card in lane.cards where !card.isDeleted && selection.ids.contains(card.id) {
                    anchor = Resolution(laneID: lane.id, anchorCardID: card.id)
                }
            }
            if let anchor { return anchor }
            // The ids name nothing the board renders — a selection the next reload will drop.
            // Falls through to the last-active lane rather than refusing: the user pressed ⌘N and
            // the board has lanes.
        }

        // Nothing selected, a tombstoned selection, or a stale one: the lane that most recently
        // held selection or a creation, and the first lane when there is no such lane (or it has
        // since gone).
        if let lastActiveLaneID, let lane = lanes.first(where: { $0.id == lastActiveLaneID }) {
            return Resolution(laneID: lane.id, anchorCardID: nil)
        }
        return lanes.first.map { Resolution(laneID: $0.id, anchorCardID: nil) }
    }
}