logic-state-layer

Decision tree — logic layer

Returns: component class, service (and its scope), or store.

Walk down and stop at the first match, except where a step tells you to read the next one before concluding. Each step down costs indirection, so earn it.

Step — component-local: does this state die with the component?

TRIGGER  the state is scoped to one component and read by nothing else
         local signals, derived values, event handlers, a form this component owns

RESULT   component class
IMPLEMENT  signal(), computed(), local form wiring — add no service for this
VERIFY     nothing outside the component reads it
           no service or store was created for it

STOP. The layer is decided.

// Search term and pagination are pure UI concerns: nothing outside this
// component reads them, so they need no service and no store.
public readonly searchTerm = signal('');
public readonly currentPage = signal(1);

public readonly displayedItems = computed(() =>
  this.items().slice((this.currentPage() - 1) * this.pageSize(), this.currentPage() * this.pageSize())
);

Step — shared or stateless: is it reused beyond one component?

CRITERION A  behaviour or state shared between components
CRITERION B  stateless and reusable regardless of sharing — a wrapper over a browser
             API, a pure computation, a cross-cutting concern such as logging
CRITERION C  orchestration across several API calls, or reusable pre/post processing

IF none is true -> go to the application-scoped step

IF any is true  -> a service covers it, but a store criterion can still apply on top.
                   Read the application-scoped step before concluding:
                     none of its criteria met -> RESULT: injectable service
                     any of its criteria met  -> RESULT: store for the state, plus a
                                                 service only for what B or C describes

CHOOSE THE SCOPE (service only)
  shared only between a container and its own subcomponents
    -> providers: [] on that container
  shared across unrelated features, and no store criterion applied
    -> providedIn: 'root'

VERIFY  the container injects it; a presenter does not, unless it is a pure
        presentation helper
        it does not select from the store — that selection belongs in the container

STOP once the application-scoped step has been read and returned no store.