Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>

…1657)

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>

- Add grouping for analyzers, build tooling, TUnit, logging and telemetry backends, DI containers, test tooling.
- Related packages now arrive in one PR instead of one PR each.

…2.3.3 (#1665)

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>

…1667)

* build: track public API with PublicApiSharp.Analyzers

- Replace Microsoft.CodeAnalysis.PublicApiAnalyzers with PublicApiSharp.Analyzers.
- Collapse the per-TFM Shipped/Unshipped file pairs into one PublicAPI.txt.
- Baselines are now ordinary C#, so a diff reads like the API change itself.
- Drop the manual AdditionalFiles wiring; the package resolves the per-TFM path.
- Swap the RS0016/RS0017 severities for PAS0004, which reports untracked TFMs.

* build: normalise line endings to LF

- Check out LF in every working tree, not just in the object database.
- Set end_of_line for editors, and mark the tracked bitmap fixture binary.

…1668)

* build: refresh dependencies and adopt the shared analyzer rule set

- Move the analyzer packages, TUnit and Verify to their current releases.
- Take the rule set the sibling repositories run, replacing the local one.
- Move the test relaxations out of the root file into src/tests.
- Drop LINQ from the container adapters' resolve and unregister paths.
- Retire suppressions for rules the shared set no longer reports.

* build: keep Application Insights v2 and v3 on their own update lines

- Cap the central package version below 3.0.0, which feeds the v2 adapter.
- Track the v3 adapter's VersionOverride, which the nuget manager cannot see.

* test: cover the rewritten resolver paths

- Exercise the generic GetServices, the empty factory list and the keyed
  lookup against a provider that is not keyed.
- Cover an Exceptionless level that has no Splat equivalent.
- Drop the null guards the rewrite made explicit; the caller rejects that
  state before reaching them, so the branch was unreachable.

* refactor(logging): gather the typed-argument overloads per logger

- Give every logging type one <Type>.TypedArguments.cs partial holding its
  overload matrix, so the rest of the type reads as logic again.
- Exempt those files from copy/paste detection and from the design rules that
  judge parameter count and file length; the matrix shape is the contract.
- Fold the Write overloads that had drifted into the Fatal partial back into
  AllocationFreeLoggerBase.

* test: cover the fatal guard on the typed-argument overloads

- Drive a logger whose inner target reports a level above fatal, which is the
  only way a consumer can switch the highest level off.
- Assert every typed Fatal overload, with and without an exception, writes
  nothing in that state.

- Install the resolver in an AsyncLocal override that only the calling flow
  observes, instead of swapping the process-wide resolver, so tests whose
  scopes overlap in time no longer steal each other's resolver.
- Scope the notification suppression WithResolver takes the same way, so one
  flow's suppression can no longer stop another flow's resolver-changed
  callbacks from running.
- Route SetLocator through the flow's override when one is active, so a
  resolver set inside a scope is confined to that flow and discarded with it.
- Short-circuit reads on a counter of live scopes, so callers that never use
  WithResolver skip the flow lookup.
- Make the returned scope idempotent, so a second dispose no longer raises a
  spurious change notification.
- Add flow-isolation tests that fail against the process-global swap, and an
  AppLocator accessor benchmark covering resolution and scope enter/exit.

…1669)

* fix(drawing): keep the aspect ratio when a decode size is requested

The imaging layer preserves proportions only when exactly one decode
dimension is set, and stretches to fit when both are. The loader set both
whenever the caller supplied both, so asking for a size whose ratio differed
from the source silently distorted the image.

- Read the source dimensions from the image header, without decoding pixels,
  and set only the dimension that constrains the result so the other is
  derived. A source that cannot be measured falls back to the requested
  width rather than stretching.
- Cover the choice of dimension, and add an end-to-end decode that fails if
  a request is applied in a way that distorts.

* refactor(drawing): drop the unreferenced duplicate platform folder

Every file under the folder targeted the Windows presentation stack and
duplicated the folder that already compiles into the desktop targets. No
item group referenced it, so it reached no target framework, and the types
it declared could not serve any other one either. Its size and point
converters still described themselves as Android conversions, which is where
they were copied from.

* fix(drawing): release the source and cover the decode paths

- Set the cache option before the resource identifier, so the image is read up
  front rather than on demand. Without it the loader held the caller's file
  open for as long as the bitmap lived.
- Measure a resource through a stream the loader owns and closes, rather than
  handing the identifier to a decoder that keeps it open. A resource that is
  not a file is left unmeasured, and the decode is then constrained by width
  alone, which still preserves the proportions.
- Cover the measuring, dimension-choosing and resource paths, including a
  request the source cannot fill, a header the codec cannot read and a
  resource that cannot be opened.

…ls (#1671)

- Read the design-mode default the designer raises for FrameworkElement
  instead of querying a freshly constructed, unparented DependencyObject.
  The designer only raises that default, so an orphan object answered false
  for any control it did not set the attached property on directly, which is
  what broke a user control nested inside another user control.
- Stop discarding the probe results. DetectDesignMode ran every probe and
  then overwrote the answer with false, so InDesignMode could only ever
  return false. The overwrite has been there since the class was extracted.
- Identify the design host by its process executable, not by the assembly
  base directory. A directory path yields an empty executable name, and the
  containment test matched every name that was a fragment of a known host
  (the empty name included), so the fallback probe reported design mode for
  every application once the overwrite above was removed. The name now has
  to match a known design host exactly.
- Skip host types the target framework cannot load: the .NET Framework and
  Windows-specific targets set UseWPF, so they call the designer API
  directly with no reflection, and the Android and Apple targets compile no
  designer probe at all. Only the target-framework-neutral builds still
  reflect, because a Windows desktop application can resolve to them.
- Drop the Silverlight probe, whose assembly cannot load on any supported
  target framework and which carried the same orphan-object defect.
- Make the memoized result resettable through the existing detector state
  hooks so tests can exercise the class, and cover both detector files to
  100% of lines and branches.

…Register (#1670)

- Hold contract registrations in a table beside the container, since Simple
  Injector has no keyed registrations. A contract registration now only answers
  a lookup for the same contract, never shadows the contract-less registration,
  and two contracts for one service type stay distinct.
- Carry the initializer's contract registrations across to the resolver when
  the container is wired up.
- Make the resolver's Register append into the container instead of silently
  doing nothing, so a registration made after the locator is wired up (a logger,
  for instance) takes effect - or fails loudly with Simple Injector's own
  exception once the container has been locked by a resolution.
- Report the collection registrations this resolver made from HasRegistration;
  Simple Injector does not surface them until the container is locked.
- Return null/empty from the initializer's non-generic lookups when a type is
  unregistered instead of throwing.

Fixes #240

…Cocoa (#1673)

* fix(drawing): honour the requested size when decoding on Android and Cocoa

- Decode Android bitmaps in two passes: read the header for the source size,
  subsample inside the decode, then settle on the exact fitted size. The
  decoder writes OutWidth and OutHeight to report what it found, so setting
  them as inputs did nothing and every bitmap came back at full size.
- Decode Cocoa bitmaps through an ImageIO image source bounded by the longest
  edge, so only the pixels that survive the request are produced. Load and
  LoadFromResource previously named the dimensions and never read them.
- Fit a requested box without distorting the image: the edge with the smaller
  scale factor binds and the other follows from the source proportions.
- Extract the arithmetic into BitmapDecodeSize, which has no platform
  dependency, so the contract is unit tested on the desktop targets instead of
  only on platforms no test runs on.

* build: exclude the unreachable platform folders from coverage analysis

The Android, Cocoa and .NET Framework platform folders compile only into target
frameworks no test project builds, so nothing loads them on any machine or CI
leg. Coverage analysis counted them as uncovered new code and disagreed with the
coverage service, which reports only what the collected reports contain.

* feat(skiasharp): add a Skia bitmap loader package

- Add Splat.SkiaSharp, an opt-in IBitmapLoader and IBitmap over SkiaSharp
  for net8.0 through net11.0, where BitmapLoader.Current has nothing to
  resolve today.
- Take an explicit Linux native asset dependency: SkiaSharp itself only
  carries the macOS and Win32 assets on these target frameworks, so
  without it the package restores and then fails to load at run time on
  the hosts it exists to serve.
- Preserve the aspect ratio when a decode size is requested, matching the
  desktop loader: both dimensions fit inside the box, one derives the
  other.
- Apply the orientation the source recorded, and report it, so an image
  stored on its side decodes upright.
- Add ToNative and FromNative that return the Skia bitmap rather than
  pretending to be a platform type, a Save overload for the formats the
  shared enumeration has no name for, and a choice of resampler.
- Register through a module and a resolver extension, with no scanning.
- Keep the native symbol files out of build and publish output, which
  they otherwise dominate.

* build(skiasharp): leave the native asset choice to the consumer

- Drop the Linux native asset reference from the library. It flowed into every
  consumer's output regardless of what they target, and clashed with the one an
  application had already chosen for itself.
- Name it in the test project instead, and only when building on Linux, since
  the base package already carries the Windows and macOS natives.