Grcov report - color.rs

1

//! CSS color types and parser.

2

//!

3

//! Core types: [`ColorU`] (u8 RGBA), [`ColorF`] (f32 RGBA), [`ColorOrSystem`]

4

//! (concrete color or runtime system-theme reference). The parser supports hex,

5

//! `rgb()`/`rgba()`, `hsl()`/`hsla()`, CSS named colors, and `system:*` syntax.

6

7

use alloc::string::{String, ToString};

8

use core::fmt;

9

10

use crate::{

11

    corety::AzString,

12

    impl_option,

13

    props::basic::{

14

        direction::{

15

            parse_direction, CssDirectionParseError, CssDirectionParseErrorOwned, Direction,

16

},

17

        error::{ParseFloatError, ParseIntError},

18

        length::{PercentageParseError, PercentageValue},

19

},

20

};

21

22

/// Round-saturating `f32` → `u8` for colour channels. Rust's `as u8` already

23

/// saturates a float (NaN→0, negatives→0, >255→255, otherwise truncates toward

24

/// zero), so this is behaviour-preserving; it just names the intent and isolates

25

/// the one unavoidable float→int cast (there is no infallible `f32`→`u8` in std).

26

#[inline]

27

#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]

28

48210

const fn channel_to_u8(v: f32) -> u8 {

29

48210

    v as u8

30

48210

31

32

/// u8-based color, range 0 to 255 (similar to webrenders `ColorU`)

33

#[derive(Debug, Copy, Clone, PartialEq, Ord, PartialOrd, Eq, Hash)]

34

#[repr(C)]

35

pub struct ColorU {

36

    pub r: u8,

37

    pub g: u8,

38

    pub b: u8,

39

    pub a: u8,

40

41

42

impl_option!(

43

    ColorU,

44

    OptionColorU,

45

    [Debug, Copy, Clone, PartialEq, Ord, PartialOrd, Eq, Hash]

46

);

47

48

impl Default for ColorU {

49

212201

    fn default() -> Self {

50

212201

        Self::BLACK

51

212201

52

53

54

impl fmt::Display for ColorU {

55

280

    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

56

280

        write!(

57

280

f,

58

280

            "rgba({}, {}, {}, {})",

59

            self.r,

60

            self.g,

61

            self.b,

62

280

            f32::from(self.a) / 255.0

63

64

280

65

66

67

// Colour math keeps explicit `a*b + c` rather than `mul_add`: the latter is a

68

// software `fmaf` (slower) without target `+fma` and changes results bit-for-bit.

69

#[allow(clippy::suboptimal_flops)]

70

impl ColorU {

71

    pub const ALPHA_TRANSPARENT: u8 = 0;

72

    pub const ALPHA_OPAQUE: u8 = 255;

73

    pub const RED: Self = Self {

74

        r: 255,

75

        g: 0,

76

        b: 0,

77

        a: Self::ALPHA_OPAQUE,

78

};

79

    pub const GREEN: Self = Self {

80

        r: 0,

81

        g: 255,

82

        b: 0,

83

        a: Self::ALPHA_OPAQUE,

84

};

85

    pub const BLUE: Self = Self {

86

        r: 0,

87

        g: 0,

88

        b: 255,

89

        a: Self::ALPHA_OPAQUE,

90

};

91

    pub const WHITE: Self = Self {

92

        r: 255,

93

        g: 255,

94

        b: 255,

95

        a: Self::ALPHA_OPAQUE,

96

};

97

    pub const BLACK: Self = Self {

98

        r: 0,

99

        g: 0,

100

        b: 0,

101

        a: Self::ALPHA_OPAQUE,

102

};

103

    pub const TRANSPARENT: Self = Self {

104

        r: 0,

105

        g: 0,

106

        b: 0,

107

        a: Self::ALPHA_TRANSPARENT,

108

};

109

110

    // Additional common colors

111

    pub const YELLOW: Self = Self {

112

        r: 255,

113

        g: 255,

114

        b: 0,

115

        a: Self::ALPHA_OPAQUE,

116

};

117

    pub const CYAN: Self = Self {

118

        r: 0,

119

        g: 255,

120

        b: 255,

121

        a: Self::ALPHA_OPAQUE,

122

};

123

    pub const MAGENTA: Self = Self {

124

        r: 255,

125

        g: 0,

126

        b: 255,

127

        a: Self::ALPHA_OPAQUE,

128

};

129

    pub const ORANGE: Self = Self {

130

        r: 255,

131

        g: 165,

132

        b: 0,

133

        a: Self::ALPHA_OPAQUE,

134

};

135

    pub const PINK: Self = Self {

136

        r: 255,

137

        g: 192,

138

        b: 203,

139

        a: Self::ALPHA_OPAQUE,

140

};

141

    pub const PURPLE: Self = Self {

142

        r: 128,

143

        g: 0,

144

        b: 128,

145

        a: Self::ALPHA_OPAQUE,

146

};

147

    pub const BROWN: Self = Self {

148

        r: 139,

149

        g: 69,

150

        b: 19,

151

        a: Self::ALPHA_OPAQUE,

152

};

153

    pub const GRAY: Self = Self {

154

        r: 128,

155

        g: 128,

156

        b: 128,

157

        a: Self::ALPHA_OPAQUE,

158

};

159

    pub const LIGHT_GRAY: Self = Self {

160

        r: 211,

161

        g: 211,

162

        b: 211,

163

        a: Self::ALPHA_OPAQUE,

164

};

165

    pub const DARK_GRAY: Self = Self {

166

        r: 64,

167

        g: 64,

168

        b: 64,

169

        a: Self::ALPHA_OPAQUE,

170

};

171

    pub const NAVY: Self = Self {

172

        r: 0,

173

        g: 0,

174

        b: 128,

175

        a: Self::ALPHA_OPAQUE,

176

};

177

    pub const TEAL: Self = Self {

178

        r: 0,

179

        g: 128,

180

        b: 128,

181

        a: Self::ALPHA_OPAQUE,

182

};

183

    pub const OLIVE: Self = Self {

184

        r: 128,

185

        g: 128,

186

        b: 0,

187

        a: Self::ALPHA_OPAQUE,

188

};

189

    pub const MAROON: Self = Self {

190

        r: 128,

191

        g: 0,

192

        b: 0,

193

        a: Self::ALPHA_OPAQUE,

194

};

195

    pub const LIME: Self = Self {

196

        r: 0,

197

        g: 255,

198

        b: 0,

199

        a: Self::ALPHA_OPAQUE,

200

};

201

    pub const AQUA: Self = Self {

202

        r: 0,

203

        g: 255,

204

        b: 255,

205

        a: Self::ALPHA_OPAQUE,

206

};

207

    pub const SILVER: Self = Self {

208

        r: 192,

209

        g: 192,

210

        b: 192,

211

        a: Self::ALPHA_OPAQUE,

212

};

213

    pub const FUCHSIA: Self = Self {

214

        r: 255,

215

        g: 0,

216

        b: 255,

217

        a: Self::ALPHA_OPAQUE,

218

};

219

    pub const INDIGO: Self = Self {

220

        r: 75,

221

        g: 0,

222

        b: 130,

223

        a: Self::ALPHA_OPAQUE,

224

};

225

    pub const GOLD: Self = Self {

226

        r: 255,

227

        g: 215,

228

        b: 0,

229

        a: Self::ALPHA_OPAQUE,

230

};

231

    pub const CORAL: Self = Self {

232

        r: 255,

233

        g: 127,

234

        b: 80,

235

        a: Self::ALPHA_OPAQUE,

236

};

237

    pub const SALMON: Self = Self {

238

        r: 250,

239

        g: 128,

240

        b: 114,

241

        a: Self::ALPHA_OPAQUE,

242

};

243

    pub const TURQUOISE: Self = Self {

244

        r: 64,

245

        g: 224,

246

        b: 208,

247

        a: Self::ALPHA_OPAQUE,

248

};

249

    pub const VIOLET: Self = Self {

250

        r: 238,

251

        g: 130,

252

        b: 238,

253

        a: Self::ALPHA_OPAQUE,

254

};

255

    pub const CRIMSON: Self = Self {

256

        r: 220,

257

        g: 20,

258

        b: 60,

259

        a: Self::ALPHA_OPAQUE,

260

};

261

    pub const CHOCOLATE: Self = Self {

262

        r: 210,

263

        g: 105,

264

        b: 30,

265

        a: Self::ALPHA_OPAQUE,

266

};

267

    pub const SKY_BLUE: Self = Self {

268

        r: 135,

269

        g: 206,

270

        b: 235,

271

        a: Self::ALPHA_OPAQUE,

272

};

273

    pub const FOREST_GREEN: Self = Self {

274

        r: 34,

275

        g: 139,

276

        b: 34,

277

        a: Self::ALPHA_OPAQUE,

278

};

279

    pub const SEA_GREEN: Self = Self {

280

        r: 46,

281

        g: 139,

282

        b: 87,

283

        a: Self::ALPHA_OPAQUE,

284

};

285

    pub const SLATE_GRAY: Self = Self {

286

        r: 112,

287

        g: 128,

288

        b: 144,

289

        a: Self::ALPHA_OPAQUE,

290

};

291

    pub const MIDNIGHT_BLUE: Self = Self {

292

        r: 25,

293

        g: 25,

294

        b: 112,

295

        a: Self::ALPHA_OPAQUE,

296

};

297

    pub const DARK_RED: Self = Self {

298

        r: 139,

299

        g: 0,

300

        b: 0,

301

        a: Self::ALPHA_OPAQUE,

302

};

303

    pub const DARK_GREEN: Self = Self {

304

        r: 0,

305

        g: 100,

306

        b: 0,

307

        a: Self::ALPHA_OPAQUE,

308

};

309

    pub const DARK_BLUE: Self = Self {

310

        r: 0,

311

        g: 0,

312

        b: 139,

313

        a: Self::ALPHA_OPAQUE,

314

};

315

    pub const LIGHT_BLUE: Self = Self {

316

        r: 173,

317

        g: 216,

318

        b: 230,

319

        a: Self::ALPHA_OPAQUE,

320

};

321

    pub const LIGHT_GREEN: Self = Self {

322

        r: 144,

323

        g: 238,

324

        b: 144,

325

        a: Self::ALPHA_OPAQUE,

326

};

327

    pub const LIGHT_YELLOW: Self = Self {

328

        r: 255,

329

        g: 255,

330

        b: 224,

331

        a: Self::ALPHA_OPAQUE,

332

};

333

    pub const LIGHT_PINK: Self = Self {

334

        r: 255,

335

        g: 182,

336

        b: 193,

337

        a: Self::ALPHA_OPAQUE,

338

};

339

340

    // Constructor functions for C API (become AzColorU_red(), AzColorU_cyan(), etc.)

341

    #[must_use]

342

2

    pub const fn red() -> Self {

343

2

        Self::RED

344

2

345

    #[must_use]

346

2

    pub const fn green() -> Self {

347

2

        Self::GREEN

348

2

349

    #[must_use]

350

2

    pub const fn blue() -> Self {

351

2

        Self::BLUE

352

2

353

    #[must_use]

354

2

    pub const fn white() -> Self {

355

2

        Self::WHITE

356

2

357

    #[must_use]

358

2

    pub const fn black() -> Self {

359

2

        Self::BLACK

360

2

361

    #[must_use]

362

3

    pub const fn transparent() -> Self {

363

3

        Self::TRANSPARENT

364

3

365

    #[must_use]

366

2

    pub const fn yellow() -> Self {

367

2

        Self::YELLOW

368

2

369

    #[must_use]

370

2

    pub const fn cyan() -> Self {

371

2

        Self::CYAN

372

2

373

    #[must_use]

374

2

    pub const fn magenta() -> Self {

375

2

        Self::MAGENTA

376

2

377

    #[must_use]

378

2

    pub const fn orange() -> Self {

379

2

        Self::ORANGE

380

2

381

    #[must_use]

382

2

    pub const fn pink() -> Self {

383

2

        Self::PINK

384

2

385

    #[must_use]

386

2

    pub const fn purple() -> Self {

387

2

        Self::PURPLE

388

2

389

    #[must_use]

390

2

    pub const fn brown() -> Self {

391

2

        Self::BROWN

392

2

393

    #[must_use]

394

2

    pub const fn gray() -> Self {

395

2

        Self::GRAY

396

2

397

    #[must_use]

398

2

    pub const fn light_gray() -> Self {

399

2

        Self::LIGHT_GRAY

400

2

401

    #[must_use]

402

2

    pub const fn dark_gray() -> Self {

403

2

        Self::DARK_GRAY

404

2

405

    #[must_use]

406

2

    pub const fn navy() -> Self {

407

2

        Self::NAVY

408

2

409

    #[must_use]

410

2

    pub const fn teal() -> Self {

411

2

        Self::TEAL

412

2

413

    #[must_use]

414

2

    pub const fn olive() -> Self {

415

2

        Self::OLIVE

416

2

417

    #[must_use]

418

2

    pub const fn maroon() -> Self {

419

2

        Self::MAROON

420

2

421

    #[must_use]

422

2

    pub const fn lime() -> Self {

423

2

        Self::LIME

424

2

425

    #[must_use]

426

2

    pub const fn aqua() -> Self {

427

2

        Self::AQUA

428

2

429

    #[must_use]

430

2

    pub const fn silver() -> Self {

431

2

        Self::SILVER

432

2

433

    #[must_use]

434

2

    pub const fn fuchsia() -> Self {

435

2

        Self::FUCHSIA

436

2

437

    #[must_use]

438

2

    pub const fn indigo() -> Self {

439

2

        Self::INDIGO

440

2

441

    #[must_use]

442

2

    pub const fn gold() -> Self {

443

2

        Self::GOLD

444

2

445

    #[must_use]

446

2

    pub const fn coral() -> Self {

447

2

        Self::CORAL

448

2

449

    #[must_use]

450

2

    pub const fn salmon() -> Self {

451

2

        Self::SALMON

452

2

453

    #[must_use]

454

2

    pub const fn turquoise() -> Self {

455

2

        Self::TURQUOISE

456

2

457

    #[must_use]

458

2

    pub const fn violet() -> Self {

459

2

        Self::VIOLET

460

2

461

    #[must_use]

462

2

    pub const fn crimson() -> Self {

463

2

        Self::CRIMSON

464

2

465

    #[must_use]

466

2

    pub const fn chocolate() -> Self {

467

2

        Self::CHOCOLATE

468

2

469

    #[must_use]

470

2

    pub const fn sky_blue() -> Self {

471

2

        Self::SKY_BLUE

472

2

473

    #[must_use]

474

2

    pub const fn forest_green() -> Self {

475

2

        Self::FOREST_GREEN

476

2

477

    #[must_use]

478

2

    pub const fn sea_green() -> Self {

479

2

        Self::SEA_GREEN

480

2

481

    #[must_use]

482

2

    pub const fn slate_gray() -> Self {

483

2

        Self::SLATE_GRAY

484

2

485

    #[must_use]

486

2

    pub const fn midnight_blue() -> Self {

487

2

        Self::MIDNIGHT_BLUE

488

2

489

    #[must_use]

490

2

    pub const fn dark_red() -> Self {

491

2

        Self::DARK_RED

492

2

493

    #[must_use]

494

2

    pub const fn dark_green() -> Self {

495

2

        Self::DARK_GREEN

496

2

497

    #[must_use]

498

2

    pub const fn dark_blue() -> Self {

499

2

        Self::DARK_BLUE

500

2

501

    #[must_use]

502

2

    pub const fn light_blue() -> Self {

503

2

        Self::LIGHT_BLUE

504

2

505

    #[must_use]

506

2

    pub const fn light_green() -> Self {

507

2

        Self::LIGHT_GREEN

508

2

509

    #[must_use]

510

2

    pub const fn light_yellow() -> Self {

511

2

        Self::LIGHT_YELLOW

512

2

513

    #[must_use]

514

2

    pub const fn light_pink() -> Self {

515

2

        Self::LIGHT_PINK

516

2

517

518

    /// Creates a new color with RGBA values.

519

    #[must_use]

520

2975

    pub const fn rgba(r: u8, g: u8, b: u8, a: u8) -> Self {

521

2975

        Self { r, g, b, a }

522

2975

523

    /// Creates a new color with RGB values (alpha = 255).

524

    #[must_use]

525

99940

    pub const fn rgb(r: u8, g: u8, b: u8) -> Self {

526

99940

        Self { r, g, b, a: 255 }

527

99940

528

    /// Alias for `rgba` - kept for internal compatibility, not exposed in FFI.

529

    #[inline]

530

    #[must_use]

531

1461

    pub const fn new(r: u8, g: u8, b: u8, a: u8) -> Self {

532

1461

        Self::rgba(r, g, b, a)

533

1461

534

    /// Alias for `rgb` - kept for internal compatibility, not exposed in FFI.

535

    #[inline]

536

    #[must_use]

537

60923

    pub const fn new_rgb(r: u8, g: u8, b: u8) -> Self {

538

60923

        Self::rgb(r, g, b)

539

60923

540

541

    /// Linearly interpolate all four RGBA channels between `self` and `other`.

542

    /// `t = 0.0` returns `self`, `t = 1.0` returns `other`.

543

    #[must_use]

544

8842

    pub fn interpolate(&self, other: &Self, t: f32) -> Self {

545

8842

        Self {

546

8842

            r: channel_to_u8(libm::roundf(

547

8842

                f32::from(self.r) + (f32::from(other.r) - f32::from(self.r)) * t,

548

8842

)),

549

8842

            g: channel_to_u8(libm::roundf(

550

8842

                f32::from(self.g) + (f32::from(other.g) - f32::from(self.g)) * t,

551

8842

)),

552

8842

            b: channel_to_u8(libm::roundf(

553

8842

                f32::from(self.b) + (f32::from(other.b) - f32::from(self.b)) * t,

554

8842

)),

555

8842

            a: channel_to_u8(libm::roundf(

556

8842

                f32::from(self.a) + (f32::from(other.a) - f32::from(self.a)) * t,

557

8842

)),

558

8842

559

8842

560

561

    /// Lighten a color by a percentage (0.0 to 1.0).

562

    /// Returns a new color blended towards white, preserving the original alpha.

563

    #[must_use]

564

5054

    pub fn lighten(&self, amount: f32) -> Self {

565

5054

        let mut c = self.interpolate(&Self::WHITE, amount.clamp(0.0, 1.0));

566

5054

        c.a = self.a;

567

5054

568

5054

569

570

    /// Darken a color by a percentage (0.0 to 1.0).

571

    /// Returns a new color blended towards black, preserving the original alpha.

572

    #[must_use]

573

1267

    pub fn darken(&self, amount: f32) -> Self {

574

1267

        let mut c = self.interpolate(&Self::BLACK, amount.clamp(0.0, 1.0));

575

1267

        c.a = self.a;

576

1267

577

1267

578

579

    /// Mix two colors together with a given ratio (0.0 = self, 1.0 = other).

580

    #[must_use]

581

8

    pub fn mix(&self, other: &Self, ratio: f32) -> Self {

582

8

        self.interpolate(other, ratio.clamp(0.0, 1.0))

583

8

584

585

    /// Create a hover variant (slightly lighter for dark colors, darker for light colors).

586

    /// This is useful for button hover states.

587

    #[must_use]

588

13

    pub fn hover_variant(&self) -> Self {

589

13

        let luminance = self.relative_luminance();

590

13

        if luminance > 0.5 {

591

4

            self.darken(0.08)

592

        } else {

593

9

            self.lighten(0.12)

594

595

13

596

597

    /// Create an active/pressed variant (darker than hover).

598

    /// This is useful for button active states.

599

    #[must_use]

600

11

    pub fn active_variant(&self) -> Self {

601

11

        let luminance = self.relative_luminance();

602

11

        if luminance > 0.5 {

603

3

            self.darken(0.15)

604

        } else {

605

8

            self.lighten(0.05)

606

607

11

608

609

    /// Calculate approximate luminance (0.0 = black, 1.0 = white).

610

///

611

    /// **Note:** This applies BT.709 coefficients directly to gamma-encoded sRGB

612

    /// values without linearizing first, so it is only an approximation.

613

    /// For accurate results (e.g. WCAG contrast checks), use [`relative_luminance()`].

614

    #[must_use]

615

396

    pub fn luminance(&self) -> f32 {

616

396

        let r = f32::from(self.r) / 255.0;

617

396

        let g = f32::from(self.g) / 255.0;

618

396

        let b = f32::from(self.b) / 255.0;

619

396

        0.2126 * r + 0.7152 * g + 0.0722 * b

620

396

621

622

    /// Returns white or black text color for best contrast on this background.

623

    #[must_use]

624

10

    pub fn contrast_text(&self) -> Self {

625

10

        self.best_contrast_text()

626

10

627

628

    // ============================================================

629

    // WCAG Accessibility and Contrast Helpers

630

    // Based on W3C WCAG 2.1 guidelines and Chromium research

631

    // ============================================================

632

633

    /// Converts a single sRGB channel to linear RGB.

634

    /// Used for accurate luminance and contrast calculations.

635

56143

    fn srgb_to_linear(c: f32) -> f32 {

636

56143

        if c <= 0.03928 {

637

15048

            c / 12.92

638

        } else {

639

41095

            libm::powf((c + 0.055) / 1.055, 2.4)

640

641

56143

642

643

    /// Calculate relative luminance per WCAG 2.1 specification.

644

    /// Returns a value between 0.0 (darkest) and 1.0 (lightest).

645

    /// Uses the sRGB to linear conversion for accurate results.

646

    #[must_use]

647

18626

    pub fn relative_luminance(&self) -> f32 {

648

18626

        let r = Self::srgb_to_linear(f32::from(self.r) / 255.0);

649

18626

        let g = Self::srgb_to_linear(f32::from(self.g) / 255.0);

650

18626

        let b = Self::srgb_to_linear(f32::from(self.b) / 255.0);

651

18626

        0.2126 * r + 0.7152 * g + 0.0722 * b

652

18626

653

654

    /// Calculate the contrast ratio between this color and another.

655

    /// Returns a value between 1.0 (no contrast) and 21.0 (max contrast).

656

///

657

    /// WCAG 2.1 requirements:

658

    /// - AA normal text: >= 4.5:1

659

    /// - AA large text: >= 3.0:1

660

    /// - AAA normal text: >= 7.0:1

661

    /// - AAA large text: >= 4.5:1

662

    #[must_use]

663

8167

    pub fn contrast_ratio(&self, other: &Self) -> f32 {

664

8167

        let l1 = self.relative_luminance();

665

8167

        let l2 = other.relative_luminance();

666

8167

        let lighter = if l1 > l2 { l1 } else { l2 };

667

8167

        let darker = if l1 > l2 { l2 } else { l1 };

668

8167

        (lighter + 0.05) / (darker + 0.05)

669

8167

670

671

    /// Check if the contrast ratio meets WCAG AA requirements for normal text (>= 4.5:1).

672

    #[must_use]

673

102

    pub fn meets_wcag_aa(&self, other: &Self) -> bool {

674

102

        self.contrast_ratio(other) >= 4.5

675

102

676

677

    /// Check if the contrast ratio meets WCAG AA requirements for large text (>= 3.0:1).

678

    /// Large text is defined as 18pt+ or 14pt+ bold.

679

    #[must_use]

680

102

    pub fn meets_wcag_aa_large(&self, other: &Self) -> bool {

681

102

        self.contrast_ratio(other) >= 3.0

682

102

683

684

    /// Check if the contrast ratio meets WCAG AAA requirements for normal text (>= 7.0:1).

685

    #[must_use]

686

102

    pub fn meets_wcag_aaa(&self, other: &Self) -> bool {

687

102

        self.contrast_ratio(other) >= 7.0

688

102

689

690

    /// Check if the contrast ratio meets WCAG AAA requirements for large text (>= 4.5:1).

691

    #[must_use]

692

100

    pub fn meets_wcag_aaa_large(&self, other: &Self) -> bool {

693

100

        self.contrast_ratio(other) >= 4.5

694

100

695

696

    /// Returns true if this color is considered "light" (relative luminance > 0.5).

697

    /// Useful for determining if dark or light text should be used.

698

    #[must_use]

699

268

    pub fn is_light(&self) -> bool {

700

268

        self.relative_luminance() > 0.5

701

268

702

703

    /// Returns true if this color is considered "dark" (relative luminance <= 0.5).

704

    #[must_use]

705

270

    pub fn is_dark(&self) -> bool {

706

270

        self.relative_luminance() <= 0.5

707

270

708

709

    /// Suggest the best text color (black or white) for this background,

710

    /// ensuring WCAG AA compliance for normal text.

711

///

712

    /// If neither black nor white meets AA requirements (unlikely),

713

    /// returns the one with higher contrast.

714

    #[must_use]

715

288

    pub fn best_contrast_text(&self) -> Self {

716

288

        let white_contrast = self.contrast_ratio(&Self::WHITE);

717

288

        let black_contrast = self.contrast_ratio(&Self::BLACK);

718

719

288

        if white_contrast >= black_contrast {

720

128

            Self::WHITE

721

        } else {

722

160

            Self::BLACK

723

724

288

725

726

    /// Adjust the color to ensure it meets the minimum contrast ratio against a background.

727

    /// Lightens or darkens the color as needed.

728

///

729

    /// Returns the original color if it already meets the requirement,

730

    /// otherwise returns an adjusted color that meets the minimum contrast.

731

    #[must_use]

732

609

    pub fn ensure_contrast(&self, background: &Self, min_ratio: f32) -> Self {

733

609

        let current_ratio = self.contrast_ratio(background);

734

609

        if current_ratio >= min_ratio {

735

225

            return *self;

736

384

737

738

        // Determine if we should lighten or darken

739

384

        let bg_luminance = background.relative_luminance();

740

384

        let should_lighten = bg_luminance < 0.5;

741

742

        // Binary search for the right amount

743

384

        let mut low = 0.0f32;

744

384

        let mut high = 1.0f32;

745

384

        let mut result = *self;

746

747

6528

        for _ in 0..16 {

748

6144

            let mid = f32::midpoint(low, high);

749

6144

            let candidate = if should_lighten {

750

4960

                self.lighten(mid)

751

            } else {

752

1184

                self.darken(mid)

753

};

754

755

6144

            if candidate.contrast_ratio(background) >= min_ratio {

756

836

                result = candidate;

757

836

                high = mid;

758

5308

            } else {

759

5308

                low = mid;

760

5308

761

762

763

384

        result

764

609

765

766

    /// Calculate the APCA (Accessible Perceptual Contrast Algorithm) contrast.

767

    /// This is a newer algorithm that may replace WCAG contrast in future standards.

768

    /// Returns a value between -108 (white on black) and 106 (black on white).

769

///

770

    /// **Note:** This is an approximation — it reuses the WCAG piecewise sRGB

771

    /// linearization and BT.709 luminance coefficients rather than the APCA-specific

772

    /// TRC exponents and coefficients from the full 0.0.98G specification.

773

///

774

    /// The sign indicates polarity (negative = light text on dark bg).

775

    /// For most purposes, use the absolute value.

776

    #[must_use]

777

416

    pub fn apca_contrast(&self, background: &Self) -> f32 {

778

        // APCA 0.0.98G constants

779

        const NORMBLKTXT: f32 = 0.56;

780

        const NORMWHT: f32 = 0.57;

781

        const REVTXT: f32 = 0.62;

782

        const REVWHT: f32 = 0.65;

783

        const BLKTHRS: f32 = 0.022;

784

        const SCALEBLKT: f32 = 1.414;

785

        const SCALEWHT: f32 = 1.14;

786

787

        // Convert to Y (luminance) using sRGB TRC

788

416

        let text_y = self.relative_luminance();

789

416

        let bg_y = background.relative_luminance();

790

791

        // Soft clamp

792

416

        let text_y = if text_y < 0.0 { 0.0 } else { text_y };

793

416

        let bg_y = if bg_y < 0.0 { 0.0 } else { bg_y };

794

795

        // Clamp black levels

796

416

        let txt_clamp = if text_y < BLKTHRS {

797

126

            text_y + libm::powf(BLKTHRS - text_y, SCALEBLKT)

798

        } else {

799

290

            text_y

800

};

801

416

        let bg_clamp = if bg_y < BLKTHRS {

802

124

            bg_y + libm::powf(BLKTHRS - bg_y, SCALEBLKT)

803

        } else {

804

292

            bg_y

805

};

806

807

        // Calculate contrast

808

416

        if bg_clamp > txt_clamp {

809

            // Dark text on light bg

810

175

            let s = (libm::powf(bg_clamp, NORMWHT) - libm::powf(txt_clamp, NORMBLKTXT)) * SCALEWHT;

811

175

            if s < 0.1 {

812

48

0.0

813

            } else {

814

127

                s * 100.0

815

816

        } else {

817

            // Light text on dark bg

818

241

            let s = (libm::powf(bg_clamp, REVWHT) - libm::powf(txt_clamp, REVTXT)) * SCALEWHT;

819

241

            if s > -0.1 {

820

116

0.0

821

            } else {

822

125

                s * 100.0

823

824

825

416

826

827

    /// Check if the APCA contrast meets the recommended minimum for body text (|Lc| >= 60).

828

    #[must_use]

829

102

    pub fn meets_apca_body(&self, background: &Self) -> bool {

830

102

        libm::fabsf(self.apca_contrast(background)) >= 60.0

831

102

832

833

    /// Check if the APCA contrast meets the minimum for large text (|Lc| >= 45).

834

    #[must_use]

835

102

    pub fn meets_apca_large(&self, background: &Self) -> bool {

836

102

        libm::fabsf(self.apca_contrast(background)) >= 45.0

837

102

838

839

    /// Set the alpha channel while keeping RGB values.

840

    #[must_use]

841

273

    pub const fn with_alpha(&self, a: u8) -> Self {

842

273

        Self {

843

273

            r: self.r,

844

273

            g: self.g,

845

273

            b: self.b,

846

273

a,

847

273

848

273

849

850

    /// Set the alpha as a float (0.0 to 1.0).

851

    #[must_use]

852

17

    pub fn with_alpha_f32(&self, a: f32) -> Self {

853

17

        self.with_alpha(channel_to_u8(a.clamp(0.0, 1.0) * 255.0))

854

17

855

856

    /// Invert the color (keeping alpha).

857

    #[must_use]

858

34

    pub const fn invert(&self) -> Self {

859

34

        Self {

860

34

            r: 255 - self.r,

861

34

            g: 255 - self.g,

862

34

            b: 255 - self.b,

863

34

            a: self.a,

864

34

865

34

866

867

    /// Convert to grayscale using luminance weights.

868

    #[must_use]

869

269

    pub fn to_grayscale(&self) -> Self {

870

269

        let gray = channel_to_u8(

871

269

            0.299 * f32::from(self.r) + 0.587 * f32::from(self.g) + 0.114 * f32::from(self.b),

872

);

873

269

        Self {

874

269

            r: gray,

875

269

            g: gray,

876

269

            b: gray,

877

269

            a: self.a,

878

269

879

269

880

881

    /// Returns `true` if the alpha channel is not fully opaque (i.e. `a != 255`).

882

    #[must_use]

883

304

    pub const fn has_alpha(&self) -> bool {

884

304

        self.a != Self::ALPHA_OPAQUE

885

304

886

887

    /// Format the color as an 8-digit lowercase hex string (e.g. `#ff0000ff`).

888

    #[must_use]

889

8328

    pub fn to_hash(&self) -> String {

890

8328

        format!("#{:02x}{:02x}{:02x}{:02x}", self.r, self.g, self.b, self.a)

891

8328

892

893

    // ============================================================

894

    // Elementary OS color palette (with shade parameter 100-900)

895

    // ============================================================

896

897

    /// Strawberry color palette (shade: 100, 300, 500, 700, 900)

898

    #[must_use]

899

33

    pub const fn strawberry(shade: usize) -> Self {

900

33

        match shade {

901

33

            0..=200 => Self::rgb(0xff, 0x8c, 0x82),   // 100: #ff8c82

902

25

            201..=400 => Self::rgb(0xed, 0x53, 0x53), // 300: #ed5353

903

20

            401..=600 => Self::rgb(0xc6, 0x26, 0x2e), // 500: #c6262e

904

15

            601..=800 => Self::rgb(0xa1, 0x07, 0x05), // 700: #a10705

905

10

            _ => Self::rgb(0x7a, 0x00, 0x00),         // 900: #7a0000

906

907

33

908

909

    /// Orange color palette (shade: 100, 300, 500, 700, 900)

910

    #[must_use]

911

31

    pub const fn palette_orange(shade: usize) -> Self {

912

31

        match shade {

913

31

            0..=200 => Self::rgb(0xff, 0xc2, 0x7d),   // 100: #ffc27d

914

24

            201..=400 => Self::rgb(0xff, 0xa1, 0x54), // 300: #ffa154

915

19

            401..=600 => Self::rgb(0xf3, 0x73, 0x29), // 500: #f37329

916

14

            601..=800 => Self::rgb(0xcc, 0x3b, 0x02), // 700: #cc3b02

917

9

            _ => Self::rgb(0xa6, 0x21, 0x00),         // 900: #a62100

918

919

31

920

921

    /// Banana color palette (shade: 100, 300, 500, 700, 900)

922

    #[must_use]

923

31

    pub const fn banana(shade: usize) -> Self {

924

31

        match shade {

925

31

            0..=200 => Self::rgb(0xff, 0xf3, 0x94),   // 100: #fff394

926

24

            201..=400 => Self::rgb(0xff, 0xe1, 0x6b), // 300: #ffe16b

927

19

            401..=600 => Self::rgb(0xf9, 0xc4, 0x40), // 500: #f9c440

928

14

            601..=800 => Self::rgb(0xd4, 0x8e, 0x15), // 700: #d48e15

929

9

            _ => Self::rgb(0xad, 0x5f, 0x00),         // 900: #ad5f00

930

931

31

932

933

    /// Lime color palette (shade: 100, 300, 500, 700, 900)

934

    #[must_use]

935

31

    pub const fn palette_lime(shade: usize) -> Self {

936

31

        match shade {

937

31

            0..=200 => Self::rgb(0xd1, 0xff, 0x82),   // 100: #d1ff82

938

24

            201..=400 => Self::rgb(0x9b, 0xdb, 0x4d), // 300: #9bdb4d

939

19

            401..=600 => Self::rgb(0x68, 0xb7, 0x23), // 500: #68b723

940

14

            601..=800 => Self::rgb(0x3a, 0x91, 0x04), // 700: #3a9104

941

9

            _ => Self::rgb(0x20, 0x6b, 0x00),         // 900: #206b00

942

943

31

944

945

    /// Mint color palette (shade: 100, 300, 500, 700, 900)

946

    #[must_use]

947

31

    pub const fn mint(shade: usize) -> Self {

948

31

        match shade {

949

31

            0..=200 => Self::rgb(0x89, 0xff, 0xdd),   // 100: #89ffdd

950

24

            201..=400 => Self::rgb(0x43, 0xd6, 0xb5), // 300: #43d6b5

951

19

            401..=600 => Self::rgb(0x28, 0xbc, 0xa3), // 500: #28bca3

952

14

            601..=800 => Self::rgb(0x0e, 0x9a, 0x83), // 700: #0e9a83

953

9

            _ => Self::rgb(0x00, 0x73, 0x67),         // 900: #007367

954

955

31

956

957

    /// Blueberry color palette (shade: 100, 300, 500, 700, 900)

958

    #[must_use]

959

31

    pub const fn blueberry(shade: usize) -> Self {

960

31

        match shade {

961

31

            0..=200 => Self::rgb(0x8c, 0xd5, 0xff),   // 100: #8cd5ff

962

24

            201..=400 => Self::rgb(0x64, 0xba, 0xff), // 300: #64baff

963

19

            401..=600 => Self::rgb(0x36, 0x89, 0xe6), // 500: #3689e6

964

14

            601..=800 => Self::rgb(0x0d, 0x52, 0xbf), // 700: #0d52bf

965

9

            _ => Self::rgb(0x00, 0x2e, 0x99),         // 900: #002e99

966

967

31

968

969

    /// Grape color palette (shade: 100, 300, 500, 700, 900)

970

    #[must_use]

971

31

    pub const fn grape(shade: usize) -> Self {

972

31

        match shade {

973

31

            0..=200 => Self::rgb(0xe4, 0xc6, 0xfa),   // 100: #e4c6fa

974

24

            201..=400 => Self::rgb(0xcd, 0x9e, 0xf7), // 300: #cd9ef7

975

19

            401..=600 => Self::rgb(0xa5, 0x6d, 0xe2), // 500: #a56de2

976

14

            601..=800 => Self::rgb(0x72, 0x39, 0xb3), // 700: #7239b3

977

9

            _ => Self::rgb(0x45, 0x29, 0x81),         // 900: #452981

978

979

31

980

981

    /// Bubblegum color palette (shade: 100, 300, 500, 700, 900)

982

    #[must_use]

983

31

    pub const fn bubblegum(shade: usize) -> Self {

984

31

        match shade {

985

31

            0..=200 => Self::rgb(0xfe, 0x9a, 0xb8),   // 100: #fe9ab8

986

24

            201..=400 => Self::rgb(0xf4, 0x67, 0x9d), // 300: #f4679d

987

19

            401..=600 => Self::rgb(0xde, 0x3e, 0x80), // 500: #de3e80

988

14

            601..=800 => Self::rgb(0xbc, 0x24, 0x5d), // 700: #bc245d

989

9

            _ => Self::rgb(0x91, 0x0e, 0x38),         // 900: #910e38

990

991

31

992

993

    /// Cocoa color palette (shade: 100, 300, 500, 700, 900)

994

    #[must_use]

995

31

    pub const fn cocoa(shade: usize) -> Self {

996

31

        match shade {

997

31

            0..=200 => Self::rgb(0xa3, 0x90, 0x7c),   // 100: #a3907c

998

24

            201..=400 => Self::rgb(0x8a, 0x71, 0x5e), // 300: #8a715e

999

19

            401..=600 => Self::rgb(0x71, 0x53, 0x44), // 500: #715344

1000

14

            601..=800 => Self::rgb(0x57, 0x39, 0x2d), // 700: #57392d

1001

9

            _ => Self::rgb(0x3d, 0x21, 0x1b),         // 900: #3d211b

1002

1003

31

1004

1005

    /// Silver color palette (shade: 100, 300, 500, 700, 900)

1006

    #[must_use]

1007

31

    pub const fn palette_silver(shade: usize) -> Self {

1008

31

        match shade {

1009

31

            0..=200 => Self::rgb(0xfa, 0xfa, 0xfa),   // 100: #fafafa

1010

24

            201..=400 => Self::rgb(0xd4, 0xd4, 0xd4), // 300: #d4d4d4

1011

19

            401..=600 => Self::rgb(0xab, 0xac, 0xae), // 500: #abacae

1012

14

            601..=800 => Self::rgb(0x7e, 0x80, 0x87), // 700: #7e8087

1013

9

            _ => Self::rgb(0x55, 0x57, 0x61),         // 900: #555761

1014

1015

31

1016

1017

    /// Slate color palette (shade: 100, 300, 500, 700, 900)

1018

    #[must_use]

1019

31

    pub const fn slate(shade: usize) -> Self {

1020

31

        match shade {

1021

31

            0..=200 => Self::rgb(0x95, 0xa3, 0xab),   // 100: #95a3ab

1022

24

            201..=400 => Self::rgb(0x66, 0x78, 0x85), // 300: #667885

1023

19

            401..=600 => Self::rgb(0x48, 0x5a, 0x6c), // 500: #485a6c

1024

14

            601..=800 => Self::rgb(0x27, 0x34, 0x45), // 700: #273445

1025

9

            _ => Self::rgb(0x0e, 0x14, 0x1f),         // 900: #0e141f

1026

1027

31

1028

1029

    /// Dark color palette (shade: 100, 300, 500, 700, 900)

1030

    #[must_use]

1031

33

    pub const fn dark(shade: usize) -> Self {

1032

33

        match shade {

1033

33

            0..=200 => Self::rgb(0x66, 0x66, 0x66),   // 100: #666

1034

26

            201..=400 => Self::rgb(0x4d, 0x4d, 0x4d), // 300: #4d4d4d

1035

21

            401..=600 => Self::rgb(0x33, 0x33, 0x33), // 500: #333

1036

16

            601..=800 => Self::rgb(0x1a, 0x1a, 0x1a), // 700: #1a1a1a

1037

11

            _ => Self::rgb(0x00, 0x00, 0x00),         // 900: #000

1038

1039

33

1040

1041

    // ============================================================

1042

    // Apple System Colors (light and dark variants)

1043

    // ============================================================

1044

1045

    /// Apple Red (light mode)

1046

    #[must_use]

1047

2

    pub const fn apple_red() -> Self {

1048

2

        Self::rgb(255, 59, 48)

1049

2

1050

    /// Apple Red (dark mode)

1051

    #[must_use]

1052

2

    pub const fn apple_red_dark() -> Self {

1053

2

        Self::rgb(255, 69, 58)

1054

2

1055

    /// Apple Orange (light mode)

1056

    #[must_use]

1057

2

    pub const fn apple_orange() -> Self {

1058

2

        Self::rgb(255, 149, 0)

1059

2

1060

    /// Apple Orange (dark mode)

1061

    #[must_use]

1062

2

    pub const fn apple_orange_dark() -> Self {

1063

2

        Self::rgb(255, 159, 10)

1064

2

1065

    /// Apple Yellow (light mode)

1066

    #[must_use]

1067

2

    pub const fn apple_yellow() -> Self {

1068

2

        Self::rgb(255, 204, 0)

1069

2

1070

    /// Apple Yellow (dark mode)

1071

    #[must_use]

1072

2

    pub const fn apple_yellow_dark() -> Self {

1073

2

        Self::rgb(255, 214, 10)

1074

2

1075

    /// Apple Green (light mode)

1076

    #[must_use]

1077

2

    pub const fn apple_green() -> Self {

1078

2

        Self::rgb(40, 205, 65)

1079

2

1080

    /// Apple Green (dark mode)

1081

    #[must_use]

1082

2

    pub const fn apple_green_dark() -> Self {

1083

2

        Self::rgb(40, 215, 75)

1084

2

1085

    /// Apple Mint (light mode)

1086

    #[must_use]

1087

2

    pub const fn apple_mint() -> Self {

1088

2

        Self::rgb(0, 199, 190)

1089

2

1090

    /// Apple Mint (dark mode)

1091

    #[must_use]

1092

2

    pub const fn apple_mint_dark() -> Self {

1093

2

        Self::rgb(102, 212, 207)

1094

2

1095

    /// Apple Teal (light mode)

1096

    #[must_use]

1097

2

    pub const fn apple_teal() -> Self {

1098

2

        Self::rgb(89, 173, 196)

1099

2

1100

    /// Apple Teal (dark mode)

1101

    #[must_use]

1102

2

    pub const fn apple_teal_dark() -> Self {

1103

2

        Self::rgb(106, 196, 220)

1104

2

1105

    /// Apple Cyan (light mode)

1106

    #[must_use]

1107

2

    pub const fn apple_cyan() -> Self {

1108

2

        Self::rgb(85, 190, 240)

1109

2

1110

    /// Apple Cyan (dark mode)

1111

    #[must_use]

1112

2

    pub const fn apple_cyan_dark() -> Self {

1113

2

        Self::rgb(90, 200, 245)

1114

2

1115

    /// Apple Blue (light mode)

1116

    #[must_use]

1117

2

    pub const fn apple_blue() -> Self {

1118

2

        Self::rgb(0, 122, 255)

1119

2

1120

    /// Apple Blue (dark mode)

1121

    #[must_use]

1122

2

    pub const fn apple_blue_dark() -> Self {

1123

2

        Self::rgb(10, 132, 255)

1124

2

1125

    /// Apple Indigo (light mode)

1126

    #[must_use]

1127

2

    pub const fn apple_indigo() -> Self {

1128

2

        Self::rgb(88, 86, 214)

1129

2

1130

    /// Apple Indigo (dark mode)

1131

    #[must_use]

1132

2

    pub const fn apple_indigo_dark() -> Self {

1133

2

        Self::rgb(94, 92, 230)

1134

2

1135

    /// Apple Purple (light mode)

1136

    #[must_use]

1137

2

    pub const fn apple_purple() -> Self {

1138

2

        Self::rgb(175, 82, 222)

1139

2

1140

    /// Apple Purple (dark mode)

1141

    #[must_use]

1142

2

    pub const fn apple_purple_dark() -> Self {

1143

2

        Self::rgb(191, 90, 242)

1144

2

1145

    /// Apple Pink (light mode)

1146

    #[must_use]

1147

2

    pub const fn apple_pink() -> Self {

1148

2

        Self::rgb(255, 45, 85)

1149

2

1150

    /// Apple Pink (dark mode)

1151

    #[must_use]

1152

2

    pub const fn apple_pink_dark() -> Self {

1153

2

        Self::rgb(255, 55, 95)

1154

2

1155

    /// Apple Brown (light mode)

1156

    #[must_use]

1157

2

    pub const fn apple_brown() -> Self {

1158

2

        Self::rgb(162, 132, 94)

1159

2

1160

    /// Apple Brown (dark mode)

1161

    #[must_use]

1162

2

    pub const fn apple_brown_dark() -> Self {

1163

2

        Self::rgb(172, 142, 104)

1164

2

1165

    /// Apple Gray (light mode)

1166

    #[must_use]

1167

2

    pub const fn apple_gray() -> Self {

1168

2

        Self::rgb(142, 142, 147)

1169

2

1170

    /// Apple Gray (dark mode)

1171

    #[must_use]

1172

2

    pub const fn apple_gray_dark() -> Self {

1173

2

        Self::rgb(152, 152, 157)

1174

2

1175

1176

    // ============================================================

1177

    // Bootstrap-style semantic button colors

1178

    // These provide consistent button styling across platforms

1179

    // ============================================================

1180

1181

    /// Primary button color (blue) - used for main actions

1182

    #[must_use]

1183

1106

    pub const fn bootstrap_primary() -> Self {

1184

1106

        Self::rgb(13, 110, 253)

1185

1106

1186

    #[must_use]

1187

1105

    pub const fn bootstrap_primary_hover() -> Self {

1188

1105

        Self::rgb(11, 94, 215)

1189

1105

1190

    #[must_use]

1191

1105

    pub const fn bootstrap_primary_active() -> Self {

1192

1105

        Self::rgb(10, 88, 202)

1193

1105

1194

1195

    /// Secondary button color (gray) - used for secondary actions

1196

    #[must_use]

1197

817

    pub const fn bootstrap_secondary() -> Self {

1198

817

        Self::rgb(108, 117, 125)

1199

817

1200

    #[must_use]

1201

817

    pub const fn bootstrap_secondary_hover() -> Self {

1202

817

        Self::rgb(92, 99, 106)

1203

817

1204

    #[must_use]

1205

817

    pub const fn bootstrap_secondary_active() -> Self {

1206

817

        Self::rgb(86, 94, 100)

1207

817

1208

1209

    /// Success button color (green) - used for confirmations

1210

    #[must_use]

1211

841

    pub const fn bootstrap_success() -> Self {

1212

841

        Self::rgb(25, 135, 84)

1213

841

1214

    #[must_use]

1215

841

    pub const fn bootstrap_success_hover() -> Self {

1216

841

        Self::rgb(21, 115, 71)

1217

841

1218

    #[must_use]

1219

841

    pub const fn bootstrap_success_active() -> Self {

1220

841

        Self::rgb(20, 108, 67)

1221

841

1222

1223

    /// Danger button color (red) - used for destructive actions

1224

    #[must_use]

1225

829

    pub const fn bootstrap_danger() -> Self {

1226

829

        Self::rgb(220, 53, 69)

1227

829

1228

    #[must_use]

1229

829

    pub const fn bootstrap_danger_hover() -> Self {

1230

829

        Self::rgb(187, 45, 59)

1231

829

1232

    #[must_use]

1233

829

    pub const fn bootstrap_danger_active() -> Self {

1234

829

        Self::rgb(176, 42, 55)

1235

829

1236

1237

    /// Warning button color (yellow) - used for warnings, uses BLACK text

1238

    #[must_use]

1239

817

    pub const fn bootstrap_warning() -> Self {

1240

817

        Self::rgb(255, 193, 7)

1241

817

1242

    #[must_use]

1243

817

    pub const fn bootstrap_warning_hover() -> Self {

1244

817

        Self::rgb(255, 202, 44)

1245

817

1246

    #[must_use]

1247

817

    pub const fn bootstrap_warning_active() -> Self {

1248

817

        Self::rgb(255, 205, 57)

1249

817

1250

1251

    /// Info button color (teal/cyan) - used for informational actions

1252

    #[must_use]

1253

841

    pub const fn bootstrap_info() -> Self {

1254

841

        Self::rgb(13, 202, 240)

1255

841

1256

    #[must_use]

1257

841

    pub const fn bootstrap_info_hover() -> Self {

1258

841

        Self::rgb(49, 210, 242)

1259

841

1260

    #[must_use]

1261

841

    pub const fn bootstrap_info_active() -> Self {

1262

841

        Self::rgb(61, 213, 243)

1263

841

1264

1265

    /// Light button color - used for light-themed buttons

1266

    #[must_use]

1267

1

    pub const fn bootstrap_light() -> Self {

1268

1

        Self::rgb(248, 249, 250)

1269

1

1270

    #[must_use]

1271

1

    pub const fn bootstrap_light_hover() -> Self {

1272

1

        Self::rgb(233, 236, 239)

1273

1

1274

    #[must_use]

1275

1

    pub const fn bootstrap_light_active() -> Self {

1276

1

        Self::rgb(218, 222, 226)

1277

1

1278

1279

    /// Dark button color - used for dark-themed buttons

1280

    #[must_use]

1281

2

    pub const fn bootstrap_dark() -> Self {

1282

2

        Self::rgb(33, 37, 41)

1283

2

1284

    #[must_use]

1285

1

    pub const fn bootstrap_dark_hover() -> Self {

1286

1

        Self::rgb(66, 70, 73)

1287

1

1288

    #[must_use]

1289

1

    pub const fn bootstrap_dark_active() -> Self {

1290

1

        Self::rgb(78, 81, 84)

1291

1

1292

1293

    /// Link button text color

1294

    #[must_use]

1295

686

    pub const fn bootstrap_link() -> Self {

1296

686

        Self::rgb(13, 110, 253)

1297

686

1298

    #[must_use]

1299

1

    pub const fn bootstrap_link_hover() -> Self {

1300

1

        Self::rgb(10, 88, 202)

1301

1

1302

1303

1304

/// f32-based color, range 0.0 to 1.0 (similar to webrenders `ColorF`)

1305

#[derive(Debug, Copy, Clone, PartialEq, PartialOrd)]

1306

pub struct ColorF {

1307

    pub r: f32,

1308

    pub g: f32,

1309

    pub b: f32,

1310

    pub a: f32,

1311

1312

1313

impl Default for ColorF {

1314

1

    fn default() -> Self {

1315

1

        Self::BLACK

1316

1

1317

1318

1319

impl fmt::Display for ColorF {

1320

7

    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

1321

7

        write!(

1322

7

f,

1323

7

            "rgba({}, {}, {}, {})",

1324

7

            self.r * 255.0,

1325

7

            self.g * 255.0,

1326

7

            self.b * 255.0,

1327

            self.a

1328

1329

7

1330

1331

1332

impl ColorF {

1333

    pub const ALPHA_TRANSPARENT: f32 = 0.0;

1334

    pub const ALPHA_OPAQUE: f32 = 1.0;

1335

    pub const WHITE: Self = Self {

1336

        r: 1.0,

1337

        g: 1.0,

1338

        b: 1.0,

1339

        a: Self::ALPHA_OPAQUE,

1340

};

1341

    pub const BLACK: Self = Self {

1342

        r: 0.0,

1343

        g: 0.0,

1344

        b: 0.0,

1345

        a: Self::ALPHA_OPAQUE,

1346

};

1347

    pub const TRANSPARENT: Self = Self {

1348

        r: 0.0,

1349

        g: 0.0,

1350

        b: 0.0,

1351

        a: Self::ALPHA_TRANSPARENT,

1352

};

1353

1354

1355

impl From<ColorU> for ColorF {

1356

256

    fn from(input: ColorU) -> Self {

1357

256

        Self {

1358

256

            r: f32::from(input.r) / 255.0,

1359

256

            g: f32::from(input.g) / 255.0,

1360

256

            b: f32::from(input.b) / 255.0,

1361

256

            a: f32::from(input.a) / 255.0,

1362

256

1363

256

1364

1365

1366

impl From<ColorF> for ColorU {

1367

259

    fn from(input: ColorF) -> Self {

1368

259

        Self {

1369

259

            r: channel_to_u8(input.r.min(1.0) * 255.0),

1370

259

            g: channel_to_u8(input.g.min(1.0) * 255.0),

1371

259

            b: channel_to_u8(input.b.min(1.0) * 255.0),

1372

259

            a: channel_to_u8(input.a.min(1.0) * 255.0),

1373

259

1374

259

1375

1376

1377

/// A color reference that can be either a concrete color or a system color.

1378

/// System colors are lazily evaluated at runtime based on the user's system theme.

1379

///

1380

/// CSS syntax: `system:accent`, `system:text`, `system:background`, etc.

1381

#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]

1382

#[repr(C, u8)]

1383

pub enum ColorOrSystem {

1384

    /// A concrete RGBA color value.

1385

    Color(ColorU),

1386

    /// A reference to a system color, resolved at runtime.

1387

    System(SystemColorRef),

1388

1389

1390

impl Default for ColorOrSystem {

1391

1

    fn default() -> Self {

1392

1

        Self::Color(ColorU::BLACK)

1393

1

1394

1395

1396

impl From<ColorU> for ColorOrSystem {

1397

1

    fn from(color: ColorU) -> Self {

1398

1

        Self::Color(color)

1399

1

1400

1401

1402

impl ColorOrSystem {

1403

    /// Create a new `ColorOrSystem` from a concrete color.

1404

    #[must_use]

1405

29

    pub const fn color(c: ColorU) -> Self {

1406

29

        Self::Color(c)

1407

29

1408

1409

    /// Create a new `ColorOrSystem` from a system color reference.

1410

    #[must_use]

1411

1

    pub const fn system(s: SystemColorRef) -> Self {

1412

1

        Self::System(s)

1413

1

1414

1415

    /// Resolve the color against a `SystemColors` struct.

1416

    /// Returns the system color if available, or falls back to the provided default.

1417

    #[must_use]

1418

90

    pub fn resolve(&self, system_colors: &crate::system::SystemColors, fallback: ColorU) -> ColorU {

1419

90

        match self {

1420

5

            Self::Color(c) => *c,

1421

85

            Self::System(ref_type) => ref_type.resolve(system_colors, fallback),

1422

1423

90

1424

1425

    /// Returns the concrete color if available, or a default fallback for system colors.

1426

    /// Use this when `SystemColors` is not available (e.g., during rendering setup).

1427

    #[must_use]

1428

5

    pub const fn to_color_u_with_fallback(&self, fallback: ColorU) -> ColorU {

1429

5

        match self {

1430

3

            Self::Color(c) => *c,

1431

2

            Self::System(_) => fallback,

1432

1433

5

1434

1435

    /// Returns the concrete color if available, or a gray fallback for system colors.

1436

    #[must_use]

1437

3

    pub const fn to_color_u_default(&self) -> ColorU {

1438

3

        self.to_color_u_with_fallback(ColorU {

1439

3

            r: 128,

1440

3

            g: 128,

1441

3

            b: 128,

1442

3

            a: 255,

1443

3

})

1444

3

1445

1446

1447

/// Reference to a specific system color.

1448

/// These are resolved at runtime based on the user's system preferences.

1449

#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]

1450

#[repr(C)]

1451

pub enum SystemColorRef {

1452

    /// System text color (e.g., black on light theme, white on dark)

1453

    Text,

1454

    /// System background color

1455

    Background,

1456

    /// System accent color (user-selected highlight color)

1457

    Accent,

1458

    /// Text color when on accent background

1459

    AccentText,

1460

    /// Button face background color

1461

    ButtonFace,

1462

    /// Button text color

1463

    ButtonText,

1464

    /// Window/panel background color

1465

    WindowBackground,

1466

    /// Selection/highlight background color

1467

    SelectionBackground,

1468

    /// Text color when selected

1469

    SelectionText,

1470

1471

1472

impl SystemColorRef {

1473

    /// Resolve this system color reference against actual system colors.

1474

    #[must_use]

1475

94

    pub fn resolve(&self, colors: &crate::system::SystemColors, fallback: ColorU) -> ColorU {

1476

94

        match self {

1477

17

            Self::Text => colors.text.as_option().copied().unwrap_or(fallback),

1478

4

            Self::Background => colors.background.as_option().copied().unwrap_or(fallback),

1479

35

            Self::Accent => colors.accent.as_option().copied().unwrap_or(fallback),

1480

4

            Self::AccentText => colors.accent_text.as_option().copied().unwrap_or(fallback),

1481

17

            Self::ButtonFace => colors.button_face.as_option().copied().unwrap_or(fallback),

1482

5

            Self::ButtonText => colors.button_text.as_option().copied().unwrap_or(fallback),

1483

4

            Self::WindowBackground => colors

1484

4

                .window_background

1485

4

                .as_option()

1486

4

                .copied()

1487

4

                .unwrap_or(fallback),

1488

4

            Self::SelectionBackground => colors

1489

4

                .selection_background

1490

4

                .as_option()

1491

4

                .copied()

1492

4

                .unwrap_or(fallback),

1493

4

            Self::SelectionText => colors

1494

4

                .selection_text

1495

4

                .as_option()

1496

4

                .copied()

1497

4

                .unwrap_or(fallback),

1498

1499

94

1500

1501

    /// Get the CSS syntax for this system color reference.

1502

    #[must_use]

1503

17

    pub const fn as_css_str(&self) -> &'static str {

1504

17

        match self {

1505

2

            Self::Text => "system:text",

1506

2

            Self::Background => "system:background",

1507

5

            Self::Accent => "system:accent",

1508

1

            Self::AccentText => "system:accent-text",

1509

1

            Self::ButtonFace => "system:button-face",

1510

1

            Self::ButtonText => "system:button-text",

1511

1

            Self::WindowBackground => "system:window-background",

1512

2

            Self::SelectionBackground => "system:selection-background",

1513

2

            Self::SelectionText => "system:selection-text",

1514

1515

17

1516

1517

1518

// --- PARSER ---

1519

1520

#[derive(Debug, Copy, Clone, PartialEq, Eq)]

1521

#[repr(C)]

1522

pub enum CssColorComponent {

1523

    Red,

1524

    Green,

1525

    Blue,

1526

    Hue,

1527

    Saturation,

1528

    Lightness,

1529

    Alpha,

1530

1531

1532

#[derive(Clone, PartialEq)]

1533

pub enum CssColorParseError<'a> {

1534

    InvalidColor(&'a str),

1535

    InvalidFunctionName(&'a str),

1536

    InvalidColorComponent(u8),

1537

    IntValueParseErr(ParseIntError),

1538

    FloatValueParseErr(ParseFloatError),

1539

    FloatValueOutOfRange(f32),

1540

    MissingColorComponent(CssColorComponent),

1541

    ExtraArguments(&'a str),

1542

    UnclosedColor(&'a str),

1543

    EmptyInput,

1544

    DirectionParseError(CssDirectionParseError<'a>),

1545

    UnsupportedDirection(&'a str),

1546

    InvalidPercentage(PercentageParseError),

1547

1548

1549

impl_debug_as_display!(CssColorParseError<'a>);

1550

impl_display! {CssColorParseError<'a>, {

1551

    InvalidColor(i) => format!("Invalid CSS color: \"{}\"", i),

1552

    InvalidFunctionName(i) => format!("Invalid function name, expected one of: \"rgb\", \"rgba\", \"hsl\", \"hsla\" got: \"{}\"", i),

1553

    InvalidColorComponent(i) => format!("Invalid color component when parsing CSS color: \"{}\"", i),

1554

    IntValueParseErr(e) => format!("CSS color component: Value not in range between 00 - FF: \"{}\"", e),

1555

    FloatValueParseErr(e) => format!("CSS color component: Value cannot be parsed as floating point number: \"{}\"", e),

1556

    FloatValueOutOfRange(v) => format!("CSS color component: Value not in range between 0.0 - 1.0: \"{}\"", v),

1557

    MissingColorComponent(c) => format!("CSS color is missing {:?} component", c),

1558

    ExtraArguments(a) => format!("Extra argument to CSS color: \"{}\"", a),

1559

    EmptyInput => format!("Empty color string."),

1560

    UnclosedColor(i) => format!("Unclosed color: \"{}\"", i),

1561

    DirectionParseError(e) => format!("Could not parse direction argument for CSS color: \"{}\"", e),

1562

    UnsupportedDirection(d) => format!("Unsupported direction type for CSS color: \"{}\"", d),

1563

    InvalidPercentage(p) => format!("Invalid percentage when parsing CSS color: \"{}\"", p),

1564

}}

1565

1566

impl From<ParseIntError> for CssColorParseError<'_> {

1567

    fn from(e: ParseIntError) -> Self {

1568

        CssColorParseError::IntValueParseErr(e)

1569

1570

1571

impl From<ParseFloatError> for CssColorParseError<'_> {

1572

    fn from(e: ParseFloatError) -> Self {

1573

        CssColorParseError::FloatValueParseErr(e)

1574

1575

1576

impl From<core::num::ParseIntError> for CssColorParseError<'_> {

1577

47

    fn from(e: core::num::ParseIntError) -> Self {

1578

47

        CssColorParseError::IntValueParseErr(ParseIntError::from(e))

1579

47

1580

1581

impl From<core::num::ParseFloatError> for CssColorParseError<'_> {

1582

6

    fn from(e: core::num::ParseFloatError) -> Self {

1583

6

        CssColorParseError::FloatValueParseErr(ParseFloatError::from(e))

1584

6

1585

1586

impl_from!(

1587

    CssDirectionParseError<'a>,

1588

    CssColorParseError::DirectionParseError

1589

);

1590

1591

#[derive(Debug, Clone, PartialEq)]

1592

#[repr(C, u8)]

1593

pub enum CssColorParseErrorOwned {

1594

    InvalidColor(AzString),

1595

    InvalidFunctionName(AzString),

1596

    InvalidColorComponent(u8),

1597

    IntValueParseErr(ParseIntError),

1598

    FloatValueParseErr(ParseFloatError),

1599

    FloatValueOutOfRange(f32),

1600

    MissingColorComponent(CssColorComponent),

1601

    ExtraArguments(AzString),

1602

    UnclosedColor(AzString),

1603

    EmptyInput,

1604

    DirectionParseError(CssDirectionParseErrorOwned),

1605

    UnsupportedDirection(AzString),

1606

    InvalidPercentage(PercentageParseError),

1607

1608

1609

impl CssColorParseError<'_> {

1610

    #[must_use]

1611

98

    pub fn to_contained(&self) -> CssColorParseErrorOwned {

1612

98

        match self {

1613

53

            CssColorParseError::InvalidColor(s) => {

1614

53

                CssColorParseErrorOwned::InvalidColor((*s).to_string().into())

1615

1616

7

            CssColorParseError::InvalidFunctionName(s) => {

1617

7

                CssColorParseErrorOwned::InvalidFunctionName((*s).to_string().into())

1618

1619

3

            CssColorParseError::InvalidColorComponent(n) => {

1620

3

                CssColorParseErrorOwned::InvalidColorComponent(*n)

1621

1622

2

            CssColorParseError::IntValueParseErr(e) => {

1623

2

                CssColorParseErrorOwned::IntValueParseErr(*e)

1624

1625

2

            CssColorParseError::FloatValueParseErr(e) => {

1626

2

                CssColorParseErrorOwned::FloatValueParseErr(*e)

1627

1628

2

            CssColorParseError::FloatValueOutOfRange(n) => {

1629

2

                CssColorParseErrorOwned::FloatValueOutOfRange(*n)

1630

1631

2

            CssColorParseError::MissingColorComponent(c) => {

1632

2

                CssColorParseErrorOwned::MissingColorComponent(*c)

1633

1634

2

            CssColorParseError::ExtraArguments(s) => {

1635

2

                CssColorParseErrorOwned::ExtraArguments((*s).to_string().into())

1636

1637

9

            CssColorParseError::UnclosedColor(s) => {

1638

9

                CssColorParseErrorOwned::UnclosedColor((*s).to_string().into())

1639

1640

12

            CssColorParseError::EmptyInput => CssColorParseErrorOwned::EmptyInput,

1641

2

            CssColorParseError::DirectionParseError(e) => {

1642

2

                CssColorParseErrorOwned::DirectionParseError(e.to_contained())

1643

1644

            CssColorParseError::UnsupportedDirection(s) => {

1645

                CssColorParseErrorOwned::UnsupportedDirection((*s).to_string().into())

1646

1647

2

            CssColorParseError::InvalidPercentage(e) => {

1648

2

                CssColorParseErrorOwned::InvalidPercentage(e.clone())

1649

1650

1651

98

1652

1653

1654

impl CssColorParseErrorOwned {

1655

    #[must_use]

1656

80

    pub fn to_shared(&self) -> CssColorParseError<'_> {

1657

80

        match self {

1658

48

            Self::InvalidColor(s) => CssColorParseError::InvalidColor(s),

1659

6

            Self::InvalidFunctionName(s) => CssColorParseError::InvalidFunctionName(s),

1660

2

            Self::InvalidColorComponent(n) => CssColorParseError::InvalidColorComponent(*n),

1661

1

            Self::IntValueParseErr(e) => CssColorParseError::IntValueParseErr(*e),

1662

1

            Self::FloatValueParseErr(e) => CssColorParseError::FloatValueParseErr(*e),

1663

1

            Self::FloatValueOutOfRange(n) => CssColorParseError::FloatValueOutOfRange(*n),

1664

1

            Self::MissingColorComponent(c) => CssColorParseError::MissingColorComponent(*c),

1665

1

            Self::ExtraArguments(s) => CssColorParseError::ExtraArguments(s),

1666

6

            Self::UnclosedColor(s) => CssColorParseError::UnclosedColor(s),

1667

11

            Self::EmptyInput => CssColorParseError::EmptyInput,

1668

1

            Self::DirectionParseError(e) => CssColorParseError::DirectionParseError(e.to_shared()),

1669

            Self::UnsupportedDirection(s) => CssColorParseError::UnsupportedDirection(s),

1670

1

            Self::InvalidPercentage(e) => CssColorParseError::InvalidPercentage(e.clone()),

1671

1672

80

1673

1674

1675

#[cfg(feature = "parser")]

1676

/// # Errors

1677

///

1678

/// Returns an error if `input` is not a valid CSS `css-color` value.

1679

222882

pub fn parse_css_color(input: &str) -> Result<ColorU, CssColorParseError<'_>> {

1680

    use crate::props::basic::parse::{parse_parentheses, ParenthesisParseError};

1681

1682

222882

    let input = input.trim();

1683

222882

    if let Some(rest) = input.strip_prefix('#') {

1684

60252

        return parse_color_no_hash(rest);

1685

162630

1686

1687

162630

    match parse_parentheses(input, &["rgba", "rgb", "hsla", "hsl"]) {

1688

8968

        Ok((stopword, inner_value)) => match stopword {

1689

8968

            "rgba" => parse_color_rgb(inner_value, true),

1690

2030

            "rgb" => parse_color_rgb(inner_value, false),

1691

1538

            "hsla" => parse_color_hsl(inner_value, true),

1692

1532

            "hsl" => parse_color_hsl(inner_value, false),

1693

            _ => unreachable!(),

1694

},

1695

153662

        Err(e) => match e {

1696

            ParenthesisParseError::UnclosedBraces | ParenthesisParseError::NoClosingBraceFound => {

1697

5554

                Err(CssColorParseError::UnclosedColor(input))

1698

1699

147

            ParenthesisParseError::EmptyInput => Err(CssColorParseError::EmptyInput),

1700

152

            ParenthesisParseError::StopWordNotFound(stopword) => {

1701

152

                Err(CssColorParseError::InvalidFunctionName(stopword))

1702

1703

147809

            ParenthesisParseError::NoOpeningBraceFound => parse_color_builtin(input),

1704

},

1705

1706

222882

1707

1708

/// Parse a color that can be either a concrete color or a system color reference.

1709

///

1710

/// Supports all standard CSS color formats plus:

1711

/// - `system:accent` - System accent/highlight color

1712

/// - `system:text` - System text color

1713

/// - `system:background` - System background color

1714

/// - `system:selection-background` - Selection/highlight background

1715

/// - `system:selection-text` - Text color when selected

1716

/// - `system:button-face` - Button background color

1717

/// - `system:button-text` - Button text color

1718

/// - `system:window-background` - Window background color

1719

/// - `system:accent-text` - Text color on accent background

1720

#[cfg(feature = "parser")]

1721

/// # Errors

1722

///

1723

/// Returns an error if `input` is not a valid CSS `color-or-system` value.

1724

64045

pub fn parse_color_or_system(input: &str) -> Result<ColorOrSystem, CssColorParseError<'_>> {

1725

64045

    let input = input.trim();

1726

1727

    // Check for system color syntax: "system:name"

1728

64045

    if let Some(system_name) = input.strip_prefix("system:") {

1729

18314

        let system_ref = match system_name.trim() {

1730

18314

            "text" => SystemColorRef::Text,

1731

18312

            "background" => SystemColorRef::Background,

1732

18310

            "accent" => SystemColorRef::Accent,

1733

18301

            "accent-text" => SystemColorRef::AccentText,

1734

18299

            "button-face" => SystemColorRef::ButtonFace,

1735

18297

            "button-text" => SystemColorRef::ButtonText,

1736

18295

            "window-background" => SystemColorRef::WindowBackground,

1737

17734

            "selection-background" => SystemColorRef::SelectionBackground,

1738

13

            "selection-text" => SystemColorRef::SelectionText,

1739

10

            _ => return Err(CssColorParseError::InvalidColor(input)),

1740

};

1741

18304

        return Ok(ColorOrSystem::System(system_ref));

1742

45731

1743

1744

    // Otherwise parse as regular color

1745

45731

    parse_css_color(input).map(ColorOrSystem::Color)

1746

64045

1747

1748

#[cfg(feature = "parser")]

1749

60266

fn parse_color_no_hash(input: &str) -> Result<ColorU, CssColorParseError<'_>> {

1750

    #[inline]

1751

26926

    const fn from_hex<'a>(c: u8) -> Result<u8, CssColorParseError<'a>> {

1752

26926

        match c {

1753

26918

            b'0'..=b'9' => Ok(c - b'0'),

1754

2016

            b'a'..=b'f' => Ok(c - b'a' + 10),

1755

35

            b'A'..=b'F' => Ok(c - b'A' + 10),

1756

41

            _ => Err(CssColorParseError::InvalidColorComponent(c)),

1757

1758

26926

1759

1760

60266

    match input.len() {

1761

        3 => {

1762

8738

            let mut bytes = input.bytes();

1763

8738

            let r = bytes.next().unwrap();

1764

8738

            let g = bytes.next().unwrap();

1765

8738

            let b = bytes.next().unwrap();

1766

8710

            Ok(ColorU::new_rgb(

1767

8738

                from_hex(r)? * 17,

1768

8710

                from_hex(g)? * 17,

1769

8710

                from_hex(b)? * 17,

1770

))

1771

1772

        4 => {

1773

201

            let mut bytes = input.bytes();

1774

201

            let r = bytes.next().unwrap();

1775

201

            let g = bytes.next().unwrap();

1776

201

            let b = bytes.next().unwrap();

1777

201

            let a = bytes.next().unwrap();

1778

188

            Ok(ColorU::new(

1779

201

                from_hex(r)? * 17,

1780

189

                from_hex(g)? * 17,

1781

189

                from_hex(b)? * 17,

1782

189

                from_hex(a)? * 17,

1783

))

1784

1785

        6 => {

1786

            // u32::from_str_radix silently accepts a leading '+' ("+f0000"), which is

1787

            // not a valid <hex-color> (CSS Color 4 §5.1: only hex digits). The 3/4-digit

1788

            // branches decode per-byte and already reject it; guard the radix branches.

1789

301780

            if !input.bytes().all(|b| b.is_ascii_hexdigit()) {

1790

34

                return Err(CssColorParseError::InvalidColor(input));

1791

50291

1792

50291

            let val = u32::from_str_radix(input, 16)?;

1793

50291

            Ok(ColorU::new_rgb(

1794

50291

                ((val >> 16) & 0xFF) as u8,

1795

50291

                ((val >> 8) & 0xFF) as u8,

1796

50291

                (val & 0xFF) as u8,

1797

50291

))

1798

1799

        8 => {

1800

7431

            if !input.bytes().all(|b| b.is_ascii_hexdigit()) {

1801

7

                return Err(CssColorParseError::InvalidColor(input));

1802

928

1803

928

            let val = u32::from_str_radix(input, 16)?;

1804

928

            Ok(ColorU::new(

1805

928

                ((val >> 24) & 0xFF) as u8,

1806

928

                ((val >> 16) & 0xFF) as u8,

1807

928

                ((val >> 8) & 0xFF) as u8,

1808

928

                (val & 0xFF) as u8,

1809

928

))

1810

1811

67

        _ => Err(CssColorParseError::InvalidColor(input)),

1812

1813

60266

1814

1815

#[cfg(feature = "parser")]

1816

7438

fn parse_color_rgb(input: &str, parse_alpha: bool) -> Result<ColorU, CssColorParseError<'_>> {

1817

7438

    let mut components = input.split(',').map(str::trim);

1818

7438

    let rgb_color = parse_color_rgb_components(&mut components)?;

1819

7367

    let a = if parse_alpha {

1820

6939

        parse_alpha_component(&mut components)?

1821

    } else {

1822

428

1823

};

1824

7331

    if let Some(arg) = components.next() {

1825

7

        return Err(CssColorParseError::ExtraArguments(arg));

1826

7324

1827

7324

    Ok(ColorU { a, ..rgb_color })

1828

7438

1829

1830

#[cfg(feature = "parser")]

1831

7449

fn parse_color_rgb_components<'a>(

1832

7449

    components: &mut dyn Iterator<Item = &'a str>,

1833

7449

) -> Result<ColorU, CssColorParseError<'a>> {

1834

    #[inline]

1835

22217

    fn component_from_str<'a>(

1836

22217

        components: &mut dyn Iterator<Item = &'a str>,

1837

22217

        which: CssColorComponent,

1838

22217

    ) -> Result<u8, CssColorParseError<'a>> {

1839

22217

        let c = components

1840

22217

            .next()

1841

22217

            .ok_or(CssColorParseError::MissingColorComponent(which))?;

1842

22203

        if c.is_empty() {

1843

19

            return Err(CssColorParseError::MissingColorComponent(which));

1844

22184

1845

22184

        Ok(c.parse::<u8>()?)

1846

22217

1847

    Ok(ColorU {

1848

7449

        r: component_from_str(components, CssColorComponent::Red)?,

1849

7385

        g: component_from_str(components, CssColorComponent::Green)?,

1850

7383

        b: component_from_str(components, CssColorComponent::Blue)?,

1851

        a: 255,

1852

})

1853

7449

1854

1855

#[cfg(feature = "parser")]

1856

1538

fn parse_color_hsl(input: &str, parse_alpha: bool) -> Result<ColorU, CssColorParseError<'_>> {

1857

1538

    let mut components = input.split(',').map(str::trim);

1858

1538

    let rgb_color = parse_color_hsl_components(&mut components)?;

1859

1527

    let a = if parse_alpha {

1860

2

        parse_alpha_component(&mut components)?

1861

    } else {

1862

1525

1863

};

1864

1526

    if let Some(arg) = components.next() {

1865

        return Err(CssColorParseError::ExtraArguments(arg));

1866

1526

1867

1526

    Ok(ColorU { a, ..rgb_color })

1868

1538

1869

1870

#[cfg(feature = "parser")]

1871

#[allow(clippy::many_single_char_names)] // domain-standard h/s/l/r/g/b colour component names

1872

1548

fn parse_color_hsl_components<'a>(

1873

1548

    components: &mut dyn Iterator<Item = &'a str>,

1874

1548

) -> Result<ColorU, CssColorParseError<'a>> {

1875

    #[inline]

1876

1548

    fn angle_from_str<'a>(

1877

1548

        components: &mut dyn Iterator<Item = &'a str>,

1878

1548

        which: CssColorComponent,

1879

1548

    ) -> Result<f32, CssColorParseError<'a>> {

1880

1548

        let c = components

1881

1548

            .next()

1882

1548

            .ok_or(CssColorParseError::MissingColorComponent(which))?;

1883

1547

        if c.is_empty() {

1884

2

            return Err(CssColorParseError::MissingColorComponent(which));

1885

1545

1886

1545

        let dir = parse_direction(c)?;

1887

1542

        match dir {

1888

1541

            Direction::Angle(deg) => Ok(deg.to_degrees()),

1889

1

            Direction::FromTo(_) => Err(CssColorParseError::UnsupportedDirection(c)),

1890

1891

1548

1892

1893

    #[inline]

1894

3076

    fn percent_from_str<'a>(

1895

3076

        components: &mut dyn Iterator<Item = &'a str>,

1896

3076

        which: CssColorComponent,

1897

3076

    ) -> Result<f32, CssColorParseError<'a>> {

1898

        use crate::props::basic::parse_percentage_value;

1899

1900

3076

        let c = components

1901

3076

            .next()

1902

3076

            .ok_or(CssColorParseError::MissingColorComponent(which))?;

1903

3072

        if c.is_empty() {

1904

2

            return Err(CssColorParseError::MissingColorComponent(which));

1905

3070

1906

1907

        // Modern CSS allows both percentage and unitless values for HSL

1908

3070

        Ok(parse_percentage_value(c)

1909

3070

            .map_err(CssColorParseError::InvalidPercentage)?

1910

3065

            .normalized()

1911

            * 100.0)

1912

3076

1913

1914

    #[inline]

1915

    #[allow(clippy::suboptimal_flops)] // explicit FP; mul_add slower without +fma

1916

    #[allow(clippy::many_single_char_names)] // domain-standard colour/coordinate component names

1917

1530

    fn hsl_to_rgb(h: f32, s: f32, l: f32) -> (u8, u8, u8) {

1918

1530

        let s = s / 100.0;

1919

1530

        let l = l / 100.0;

1920

1530

        let c = (1.0 - (2.0 * l - 1.0).abs()) * s;

1921

1530

        let h_prime = h / 60.0;

1922

1530

        let x = c * (1.0 - ((h_prime % 2.0) - 1.0).abs());

1923

1530

        let (r1, g1, b1) = if (0.0..1.0).contains(&h_prime) {

1924

948

            (c, x, 0.0)

1925

582

        } else if (1.0..2.0).contains(&h_prime) {

1926

            (x, c, 0.0)

1927

582

        } else if (2.0..3.0).contains(&h_prime) {

1928

132

            (0.0, c, x)

1929

450

        } else if (3.0..4.0).contains(&h_prime) {

1930

407

            (0.0, x, c)

1931

43

        } else if (4.0..5.0).contains(&h_prime) {

1932

43

            (x, 0.0, c)

1933

        } else {

1934

            (c, 0.0, x)

1935

};

1936

1530

        let m = l - c / 2.0;

1937

1530

1938

1530

            channel_to_u8((r1 + m) * 255.0),

1939

1530

            channel_to_u8((g1 + m) * 255.0),

1940

1530

            channel_to_u8((b1 + m) * 255.0),

1941

1530

1942

1530

1943

1944

1530

    let (h, s, l) = (

1945

1548

        angle_from_str(components, CssColorComponent::Hue)?,

1946

1541

        percent_from_str(components, CssColorComponent::Saturation)?,

1947

1535

        percent_from_str(components, CssColorComponent::Lightness)?,

1948

);

1949

1950

1530

    let (r, g, b) = hsl_to_rgb(h, s, l);

1951

1530

    Ok(ColorU { r, g, b, a: 255 })

1952

1548

1953

1954

#[cfg(feature = "parser")]

1955

6959

fn parse_alpha_component<'a>(

1956

6959

    components: &mut dyn Iterator<Item = &'a str>,

1957

6959

) -> Result<u8, CssColorParseError<'a>> {

1958

6959

    let a_str = components

1959

6959

        .next()

1960

6959

        .ok_or(CssColorParseError::MissingColorComponent(

1961

6959

            CssColorComponent::Alpha,

1962

6959

        ))?;

1963

6952

    if a_str.is_empty() {

1964

1

        return Err(CssColorParseError::MissingColorComponent(

1965

1

            CssColorComponent::Alpha,

1966

1

));

1967

6951

1968

6951

    let a = a_str.parse::<f32>()?;

1969

6945

    if !(0.0..=1.0).contains(&a) {

1970

36

        return Err(CssColorParseError::FloatValueOutOfRange(a));

1971

6909

1972

6909

    Ok(channel_to_u8((a * 255.0).round()))

1973

6959

1974

1975

#[cfg(feature = "parser")]

1976

#[allow(clippy::too_many_lines)] // large but cohesive: single-purpose CSS parser/formatter/dispatch

1977

                                 // table (one branch per property/variant)

1978

147817

fn parse_color_builtin(input: &str) -> Result<ColorU, CssColorParseError<'_>> {

1979

147817

    let (r, g, b, a) = match input.to_lowercase().as_str() {

1980

147817

        "aliceblue" => (240, 248, 255, 255),

1981

147817

        "antiquewhite" => (250, 235, 215, 255),

1982

147817

        "aqua" | "cyan" => (0, 255, 255, 255),

1983

147817

        "aquamarine" => (127, 255, 212, 255),

1984

147817

        "azure" => (240, 255, 255, 255),

1985

147817

        "beige" => (245, 245, 220, 255),

1986

147817

        "bisque" => (255, 228, 196, 255),

1987

147817

        "black" => (0, 0, 0, 255),

1988

146805

        "blanchedalmond" => (255, 235, 205, 255),

1989

146805

        "blue" => (0, 0, 255, 255),

1990

145278

        "blueviolet" => (138, 43, 226, 255),

1991

145278

        "brown" => (165, 42, 42, 255),

1992

145278

        "burlywood" => (222, 184, 135, 255),

1993

145278

        "cadetblue" => (95, 158, 160, 255),

1994

145278

        "chartreuse" => (127, 255, 0, 255),

1995

145278

        "chocolate" => (210, 105, 30, 255),

1996

145278

        "coral" => (255, 127, 80, 255),

1997

145278

        "cornflowerblue" => (100, 149, 237, 255),

1998

145278

        "cornsilk" => (255, 248, 220, 255),

1999

145278

        "crimson" => (220, 20, 60, 255),

2000

145278

        "darkblue" => (0, 0, 139, 255),

2001

145278

        "darkcyan" => (0, 139, 139, 255),

2002

145278

        "darkgoldenrod" => (184, 134, 11, 255),

2003

145278

        "darkgray" | "darkgrey" => (169, 169, 169, 255),

2004

145278

        "darkgreen" => (0, 100, 0, 255),

2005

145278

        "darkkhaki" => (189, 183, 107, 255),

2006

145278

        "darkmagenta" => (139, 0, 139, 255),

2007

145278

        "darkolivegreen" => (85, 107, 47, 255),

2008

145278

        "darkorange" => (255, 140, 0, 255),

2009

145278

        "darkorchid" => (153, 50, 204, 255),

2010

145278

        "darkred" => (139, 0, 0, 255),

2011

145278

        "darksalmon" => (233, 150, 122, 255),

2012

145278

        "darkseagreen" => (143, 188, 143, 255),

2013

145278

        "darkslateblue" => (72, 61, 139, 255),

2014

145278

        "darkslategray" | "darkslategrey" => (47, 79, 79, 255),

2015

145278

        "darkturquoise" => (0, 206, 209, 255),

2016

145278

        "darkviolet" => (148, 0, 211, 255),

2017

145278

        "deeppink" => (255, 20, 147, 255),

2018

145278

        "deepskyblue" => (0, 191, 255, 255),

2019

145278

        "dimgray" | "dimgrey" => (105, 105, 105, 255),

2020

145278

        "dodgerblue" => (30, 144, 255, 255),

2021

145278

        "firebrick" => (178, 34, 34, 255),

2022

145278

        "floralwhite" => (255, 250, 240, 255),

2023

145278

        "forestgreen" => (34, 139, 34, 255),

2024

145278

        "fuchsia" | "magenta" => (255, 0, 255, 255),

2025

145278

        "gainsboro" => (220, 220, 220, 255),

2026

145252

        "ghostwhite" => (248, 248, 255, 255),

2027

145252

        "gold" => (255, 215, 0, 255),

2028

145239

        "goldenrod" => (218, 165, 32, 255),

2029

145239

        "gray" | "grey" => (128, 128, 128, 255),

2030

145199

        "green" => (0, 128, 0, 255),

2031

144596

        "greenyellow" => (173, 255, 47, 255),

2032

144596

        "honeydew" => (240, 255, 240, 255),

2033

144596

        "hotpink" => (255, 105, 180, 255),

2034

144596

        "indianred" => (205, 92, 92, 255),

2035

144596

        "indigo" => (75, 0, 130, 255),

2036

144596

        "ivory" => (255, 255, 240, 255),

2037

144596

        "khaki" => (240, 230, 140, 255),

2038

144596

        "lavender" => (230, 230, 250, 255),

2039

144596

        "lavenderblush" => (255, 240, 245, 255),

2040

144596

        "lawngreen" => (124, 252, 0, 255),

2041

144596

        "lemonchiffon" => (255, 250, 205, 255),

2042

144596

        "lightblue" => (173, 216, 230, 255),

2043

144596

        "lightcoral" => (240, 128, 128, 255),

2044

144596

        "lightcyan" => (224, 255, 255, 255),

2045

144596

        "lightgoldenrodyellow" => (250, 250, 210, 255),

2046

144596

        "lightgray" | "lightgrey" => (211, 211, 211, 255),

2047

144596

        "lightgreen" => (144, 238, 144, 255),

2048

144596

        "lightpink" => (255, 182, 193, 255),

2049

144596

        "lightsalmon" => (255, 160, 122, 255),

2050

144596

        "lightseagreen" => (32, 178, 170, 255),

2051

144596

        "lightskyblue" => (135, 206, 250, 255),

2052

144596

        "lightslategray" | "lightslategrey" => (119, 136, 153, 255),

2053

144596

        "lightsteelblue" => (176, 196, 222, 255),

2054

144596

        "lightyellow" => (255, 255, 224, 255),

2055

144596

        "lime" => (0, 255, 0, 255),

2056

144576

        "limegreen" => (50, 205, 50, 255),

2057

144576

        "linen" => (250, 240, 230, 255),

2058

144576

        "maroon" => (128, 0, 0, 255),

2059

144576

        "mediumaquamarine" => (102, 205, 170, 255),

2060

144576

        "mediumblue" => (0, 0, 205, 255),

2061

144576

        "mediumorchid" => (186, 85, 211, 255),

2062

144576

        "mediumpurple" => (147, 112, 219, 255),

2063

144576

        "mediumseagreen" => (60, 179, 113, 255),

2064

144576

        "mediumslateblue" => (123, 104, 238, 255),

2065

144576

        "mediumspringgreen" => (0, 250, 154, 255),

2066

144576

        "mediumturquoise" => (72, 209, 204, 255),

2067

144576

        "mediumvioletred" => (199, 21, 133, 255),

2068

144576

        "midnightblue" => (25, 25, 112, 255),

2069

144576

        "mintcream" => (245, 255, 250, 255),

2070

144576

        "mistyrose" => (255, 228, 225, 255),

2071

144576

        "moccasin" => (255, 228, 181, 255),

2072

144576

        "navajowhite" => (255, 222, 173, 255),

2073

144576

        "navy" => (0, 0, 128, 255),

2074

144576

        "oldlace" => (253, 245, 230, 255),

2075

144576

        "olive" => (128, 128, 0, 255),

2076

144576

        "olivedrab" => (107, 142, 35, 255),

2077

144576

        "orange" => (255, 165, 0, 255),

2078

144524

        "orangered" => (255, 69, 0, 255),

2079

144524

        "orchid" => (218, 112, 214, 255),

2080

144524

        "palegoldenrod" => (238, 232, 170, 255),

2081

144524

        "palegreen" => (152, 251, 152, 255),

2082

144524

        "paleturquoise" => (175, 238, 238, 255),

2083

144524

        "palevioletred" => (219, 112, 147, 255),

2084

144524

        "papayawhip" => (255, 239, 213, 255),

2085

144524

        "peachpuff" => (255, 218, 185, 255),

2086

144524

        "peru" => (205, 133, 63, 255),

2087

144524

        "pink" => (255, 192, 203, 255),

2088

144524

        "plum" => (221, 160, 221, 255),

2089

144524

        "powderblue" => (176, 224, 230, 255),

2090

144524

        "purple" => (128, 0, 128, 255),

2091

144471

        "rebeccapurple" => (102, 51, 153, 255),

2092

144469

        "red" => (255, 0, 0, 255),

2093

122674

        "rosybrown" => (188, 143, 143, 255),

2094

122674

        "royalblue" => (65, 105, 225, 255),

2095

122674

        "saddlebrown" => (139, 69, 19, 255),

2096

122674

        "salmon" => (250, 128, 114, 255),

2097

122674

        "sandybrown" => (244, 164, 96, 255),

2098

122674

        "seagreen" => (46, 139, 87, 255),

2099

122674

        "seashell" => (255, 245, 238, 255),

2100

122674

        "sienna" => (160, 82, 45, 255),

2101

122674

        "silver" => (192, 192, 192, 255),

2102

122414

        "skyblue" => (135, 206, 235, 255),

2103

122414

        "slateblue" => (106, 90, 205, 255),

2104

122414

        "slategray" | "slategrey" => (112, 128, 144, 255),

2105

122414

        "snow" => (255, 250, 250, 255),

2106

122414

        "springgreen" => (0, 255, 127, 255),

2107

122414

        "steelblue" => (70, 130, 180, 255),

2108

122414

        "tan" => (210, 180, 140, 255),

2109

122414

        "teal" => (0, 128, 128, 255),

2110

122362

        "thistle" => (216, 191, 216, 255),

2111

122362

        "tomato" => (255, 99, 71, 255),

2112

122362

        "transparent" => (0, 0, 0, 0),

2113

122322

        "turquoise" => (64, 224, 208, 255),

2114

122322

        "violet" => (238, 130, 238, 255),

2115

122322

        "wheat" => (245, 222, 179, 255),

2116

122322

        "white" => (255, 255, 255, 255),

2117

119814

        "whitesmoke" => (245, 245, 245, 255),

2118

119814

        "yellow" => (255, 255, 0, 255),

2119

119765

        "yellowgreen" => (154, 205, 50, 255),

2120

119765

        _ => return Err(CssColorParseError::InvalidColor(input)),

2121

};

2122

28052

    Ok(ColorU { r, g, b, a })

2123

147817

2124

2125

#[cfg(all(test, feature = "parser"))]

2126

mod tests {

2127

    use super::*;

2128

2129

    #[test]

2130

1

    fn test_parse_color_keywords() {

2131

1

        assert_eq!(parse_css_color("red").unwrap(), ColorU::RED);

2132

1

        assert_eq!(parse_css_color("blue").unwrap(), ColorU::BLUE);

2133

1

        assert_eq!(parse_css_color("transparent").unwrap(), ColorU::TRANSPARENT);

2134

1

        assert_eq!(

2135

1

            parse_css_color("rebeccapurple").unwrap(),

2136

1

            ColorU::new_rgb(102, 51, 153)

2137

);

2138

1

2139

2140

    #[test]

2141

1

    fn test_parse_color_hex() {

2142

        // 3-digit

2143

1

        assert_eq!(parse_css_color("#f00").unwrap(), ColorU::RED);

2144

        // 4-digit

2145

1

        assert_eq!(

2146

1

            parse_css_color("#f008").unwrap(),

2147

1

            ColorU::new(255, 0, 0, 136)

2148

);

2149

        // 6-digit

2150

1

        assert_eq!(parse_css_color("#00ff00").unwrap(), ColorU::GREEN);

2151

        // 8-digit

2152

1

        assert_eq!(

2153

1

            parse_css_color("#0000ff80").unwrap(),

2154

1

            ColorU::new(0, 0, 255, 128)

2155

);

2156

        // Uppercase

2157

1

        assert_eq!(

2158

1

            parse_css_color("#FFC0CB").unwrap(),

2159

1

            ColorU::new_rgb(255, 192, 203)

2160

        ); // Pink

2161

1

2162

2163

    #[test]

2164

1

    fn test_parse_color_rgb() {

2165

1

        assert_eq!(parse_css_color("rgb(255, 0, 0)").unwrap(), ColorU::RED);

2166

1

        assert_eq!(

2167

1

            parse_css_color("rgba(0, 255, 0, 0.5)").unwrap(),

2168

1

            ColorU::new(0, 255, 0, 128)

2169

);

2170

1

        assert_eq!(

2171

1

            parse_css_color("rgba(10, 20, 30, 1)").unwrap(),

2172

1

            ColorU::new_rgb(10, 20, 30)

2173

);

2174

1

        assert_eq!(parse_css_color("rgb( 0 , 0 , 0 )").unwrap(), ColorU::BLACK);

2175

1

2176

2177

    #[test]

2178

1

    fn test_parse_color_hsl() {

2179

1

        assert_eq!(parse_css_color("hsl(0, 100%, 50%)").unwrap(), ColorU::RED);

2180

1

        assert_eq!(

2181

1

            parse_css_color("hsl(120, 100%, 50%)").unwrap(),

2182

            ColorU::GREEN

2183

);

2184

1

        assert_eq!(

2185

1

            parse_css_color("hsla(240, 100%, 50%, 0.5)").unwrap(),

2186

1

            ColorU::new(0, 0, 255, 128)

2187

);

2188

1

        assert_eq!(parse_css_color("hsl(0, 0%, 0%)").unwrap(), ColorU::BLACK);

2189

1

2190

2191

    #[test]

2192

1

    fn test_parse_color_errors() {

2193

1

        assert!(parse_css_color("redd").is_err());

2194

1

        assert!(parse_css_color("#12345").is_err()); // Invalid length

2195

1

        assert!(parse_css_color("#ggg").is_err()); // Invalid hex digit

2196

1

        assert!(parse_css_color("rgb(255, 0)").is_err()); // Missing component

2197

1

        assert!(parse_css_color("rgba(255, 0, 0, 2)").is_err()); // Alpha out of range

2198

1

        assert!(parse_css_color("rgb(256, 0, 0)").is_err()); // Value out of range

2199

                                                             // Modern CSS allows both hsl(0, 100%,

2200

                                                             // 50%) and hsl(0 100 50)

2201

1

        assert!(parse_css_color("hsl(0, 100, 50%)").is_ok()); // Valid in modern CSS

2202

1

        assert!(parse_css_color("rgb(255 0 0)").is_err()); // Missing commas (this implementation

2203

                                                           // requires commas)

2204

1

2205

2206

    #[test]

2207

1

    fn test_parse_system_colors() {

2208

        // Test parsing system color syntax

2209

1

        assert_eq!(

2210

1

            parse_color_or_system("system:accent").unwrap(),

2211

            ColorOrSystem::System(SystemColorRef::Accent)

2212

);

2213

1

        assert_eq!(

2214

1

            parse_color_or_system("system:text").unwrap(),

2215

            ColorOrSystem::System(SystemColorRef::Text)

2216

);

2217

1

        assert_eq!(

2218

1

            parse_color_or_system("system:background").unwrap(),

2219

            ColorOrSystem::System(SystemColorRef::Background)

2220

);

2221

1

        assert_eq!(

2222

1

            parse_color_or_system("system:selection-background").unwrap(),

2223

            ColorOrSystem::System(SystemColorRef::SelectionBackground)

2224

);

2225

1

        assert_eq!(

2226

1

            parse_color_or_system("system:selection-text").unwrap(),

2227

            ColorOrSystem::System(SystemColorRef::SelectionText)

2228

);

2229

1

        assert_eq!(

2230

1

            parse_color_or_system("system:accent-text").unwrap(),

2231

            ColorOrSystem::System(SystemColorRef::AccentText)

2232

);

2233

1

        assert_eq!(

2234

1

            parse_color_or_system("system:button-face").unwrap(),

2235

            ColorOrSystem::System(SystemColorRef::ButtonFace)

2236

);

2237

1

        assert_eq!(

2238

1

            parse_color_or_system("system:button-text").unwrap(),

2239

            ColorOrSystem::System(SystemColorRef::ButtonText)

2240

);

2241

1

        assert_eq!(

2242

1

            parse_color_or_system("system:window-background").unwrap(),

2243

            ColorOrSystem::System(SystemColorRef::WindowBackground)

2244

);

2245

2246

        // Invalid system color should error

2247

1

        assert!(parse_color_or_system("system:invalid").is_err());

2248

2249

        // Regular colors should still work

2250

1

        assert_eq!(

2251

1

            parse_color_or_system("red").unwrap(),

2252

            ColorOrSystem::Color(ColorU::RED)

2253

);

2254

1

        assert_eq!(

2255

1

            parse_color_or_system("#ff0000").unwrap(),

2256

            ColorOrSystem::Color(ColorU::RED)

2257

);

2258

1

2259

2260

    #[test]

2261

1

    fn test_system_color_resolution() {

2262

        use crate::system::SystemColors;

2263

2264

1

        let system_colors = SystemColors {

2265

1

            text: OptionColorU::Some(ColorU::BLACK),

2266

1

            secondary_text: OptionColorU::None,

2267

1

            tertiary_text: OptionColorU::None,

2268

1

            background: OptionColorU::Some(ColorU::WHITE),

2269

1

            accent: OptionColorU::Some(ColorU::new_rgb(0, 122, 255)), // macOS blue

2270

1

            accent_text: OptionColorU::Some(ColorU::WHITE),

2271

1

            button_face: OptionColorU::Some(ColorU::new_rgb(240, 240, 240)),

2272

1

            button_text: OptionColorU::Some(ColorU::BLACK),

2273

1

            disabled_text: OptionColorU::None,

2274

1

            window_background: OptionColorU::Some(ColorU::WHITE),

2275

1

            under_page_background: OptionColorU::None,

2276

1

            selection_background: OptionColorU::Some(ColorU::new_rgb(0, 120, 215)),

2277

1

            selection_text: OptionColorU::Some(ColorU::WHITE),

2278

1

            selection_background_inactive: OptionColorU::None,

2279

1

            selection_text_inactive: OptionColorU::None,

2280

1

            link: OptionColorU::None,

2281

1

            separator: OptionColorU::None,

2282

1

            grid: OptionColorU::None,

2283

1

            find_highlight: OptionColorU::None,

2284

1

            sidebar_background: OptionColorU::None,

2285

1

            sidebar_selection: OptionColorU::None,

2286

1

};

2287

2288

        // Test resolution of system colors

2289

1

        let accent_ref = ColorOrSystem::System(SystemColorRef::Accent);

2290

1

        let resolved = accent_ref.resolve(&system_colors, ColorU::GRAY);

2291

1

        assert_eq!(resolved, ColorU::new_rgb(0, 122, 255));

2292

2293

        // Test resolution with fallback when color is not set

2294

1

        let empty_colors = SystemColors::default();

2295

1

        let resolved_fallback = accent_ref.resolve(&empty_colors, ColorU::GRAY);

2296

1

        assert_eq!(resolved_fallback, ColorU::GRAY);

2297

2298

        // Test that concrete colors just return themselves

2299

1

        let concrete = ColorOrSystem::Color(ColorU::RED);

2300

1

        let resolved_concrete = concrete.resolve(&system_colors, ColorU::GRAY);

2301

1

        assert_eq!(resolved_concrete, ColorU::RED);

2302

1

2303

2304

    #[test]

2305

1

    fn test_system_color_css_str() {

2306

1

        assert_eq!(SystemColorRef::Accent.as_css_str(), "system:accent");

2307

1

        assert_eq!(SystemColorRef::Text.as_css_str(), "system:text");

2308

1

        assert_eq!(SystemColorRef::Background.as_css_str(), "system:background");

2309

1

        assert_eq!(

2310

1

            SystemColorRef::SelectionBackground.as_css_str(),

2311

            "system:selection-background"

2312

);

2313

1

2314

2315

2316

#[cfg(test)]

2317

#[allow(clippy::float_cmp, clippy::unreadable_literal)]

2318

mod autotest_generated {

2319

    use super::*;

2320

2321

    /// Every `ColorU` this module sweeps over. Chosen to hit the interesting

2322

    /// channel boundaries (0 / 1 / 127 / 128 / 254 / 255) plus a few real colors.

2323

    const SAMPLES: [ColorU; 10] = [

2324

        ColorU {

2325

            r: 0,

2326

            g: 0,

2327

            b: 0,

2328

            a: 0,

2329

},

2330

        ColorU {

2331

            r: 0,

2332

            g: 0,

2333

            b: 0,

2334

            a: 255,

2335

},

2336

        ColorU {

2337

            r: 255,

2338

            g: 255,

2339

            b: 255,

2340

            a: 255,

2341

},

2342

        ColorU {

2343

            r: 255,

2344

            g: 255,

2345

            b: 255,

2346

            a: 0,

2347

},

2348

        ColorU {

2349

            r: 1,

2350

            g: 2,

2351

            b: 3,

2352

            a: 4,

2353

},

2354

        ColorU {

2355

            r: 127,

2356

            g: 128,

2357

            b: 129,

2358

            a: 254,

2359

},

2360

        ColorU {

2361

            r: 254,

2362

            g: 1,

2363

            b: 128,

2364

            a: 1,

2365

},

2366

        ColorU {

2367

            r: 128,

2368

            g: 128,

2369

            b: 128,

2370

            a: 255,

2371

},

2372

        ColorU {

2373

            r: 255,

2374

            g: 0,

2375

            b: 0,

2376

            a: 255,

2377

},

2378

        ColorU {

2379

            r: 13,

2380

            g: 110,

2381

            b: 253,

2382

            a: 200,

2383

},

2384

];

2385

2386

    // =====================================================================

2387

    // numeric: channel_to_u8 (private) — the one float→int cast in the file

2388

    // =====================================================================

2389

2390

    #[test]

2391

    fn channel_to_u8_zero_and_negative_zero() {

2392

        assert_eq!(channel_to_u8(0.0), 0);

2393

        assert_eq!(channel_to_u8(-0.0), 0);

2394

2395

2396

    #[test]

2397

    fn channel_to_u8_truncates_toward_zero_and_does_not_round() {

2398

        assert_eq!(channel_to_u8(0.9), 0);

2399

        assert_eq!(channel_to_u8(127.5), 127);

2400

        assert_eq!(channel_to_u8(254.999), 254);

2401

        assert_eq!(channel_to_u8(255.0), 255);

2402

        assert_eq!(channel_to_u8(255.9), 255);

2403

2404

2405

    #[test]

2406

    fn channel_to_u8_saturates_on_overflow_instead_of_wrapping() {

2407

        assert_eq!(channel_to_u8(256.0), 255);

2408

        assert_eq!(channel_to_u8(1e30), 255);

2409

        assert_eq!(channel_to_u8(f32::MAX), 255);

2410

2411

2412

    #[test]

2413

    fn channel_to_u8_negative_saturates_to_zero() {

2414

        assert_eq!(channel_to_u8(-0.5), 0);

2415

        assert_eq!(channel_to_u8(-1.0), 0);

2416

        assert_eq!(channel_to_u8(-1e30), 0);

2417

        assert_eq!(channel_to_u8(f32::MIN), 0);

2418

2419

2420

    #[test]

2421

    fn channel_to_u8_nan_and_inf_are_defined_and_do_not_panic() {

2422

        assert_eq!(channel_to_u8(f32::NAN), 0);

2423

        assert_eq!(channel_to_u8(-f32::NAN), 0);

2424

        assert_eq!(channel_to_u8(f32::INFINITY), 255);

2425

        assert_eq!(channel_to_u8(f32::NEG_INFINITY), 0);

2426

2427

2428

    #[test]

2429

    fn channel_to_u8_subnormal_inputs_do_not_panic() {

2430

        assert_eq!(channel_to_u8(f32::MIN_POSITIVE), 0);

2431

        assert_eq!(channel_to_u8(1e-45), 0);

2432

        assert_eq!(channel_to_u8(-1e-45), 0);

2433

2434

2435

    // =====================================================================

2436

    // constructors: rgba / rgb / new / new_rgb / with_alpha / with_alpha_f32

2437

    // =====================================================================

2438

2439

    #[test]

2440

    fn rgba_fields_match_args_at_min_and_max() {

2441

        let min = ColorU::rgba(0, 0, 0, 0);

2442

        assert_eq!((min.r, min.g, min.b, min.a), (0, 0, 0, 0));

2443

        let max = ColorU::rgba(u8::MAX, u8::MAX, u8::MAX, u8::MAX);

2444

        assert_eq!((max.r, max.g, max.b, max.a), (255, 255, 255, 255));

2445

        let mixed = ColorU::rgba(1, 2, 3, 4);

2446

        assert_eq!((mixed.r, mixed.g, mixed.b, mixed.a), (1, 2, 3, 4));

2447

2448

2449

    #[test]

2450

    fn rgb_defaults_alpha_to_opaque() {

2451

        assert_eq!(ColorU::rgb(0, 0, 0), ColorU::BLACK);

2452

        assert_eq!(ColorU::rgb(1, 2, 3).a, ColorU::ALPHA_OPAQUE);

2453

        assert_eq!(ColorU::rgb(u8::MAX, u8::MAX, u8::MAX), ColorU::WHITE);

2454

2455

2456

    #[test]

2457

    fn new_and_new_rgb_are_exact_aliases() {

2458

        for c in SAMPLES {

2459

            assert_eq!(

2460

                ColorU::new(c.r, c.g, c.b, c.a),

2461

                ColorU::rgba(c.r, c.g, c.b, c.a)

2462

);

2463

            assert_eq!(ColorU::new_rgb(c.r, c.g, c.b), ColorU::rgb(c.r, c.g, c.b));

2464

2465

2466

2467

    #[test]

2468

    fn with_alpha_keeps_rgb_for_every_alpha() {

2469

        let base = ColorU::rgba(13, 110, 253, 7);

2470

        for a in 0..=u8::MAX {

2471

            let c = base.with_alpha(a);

2472

            assert_eq!((c.r, c.g, c.b), (base.r, base.g, base.b));

2473

            assert_eq!(c.a, a);

2474

2475

2476

2477

    #[test]

2478

    fn with_alpha_f32_clamps_out_of_range_and_nan() {

2479

        let base = ColorU::rgb(1, 2, 3);

2480

        assert_eq!(base.with_alpha_f32(0.0).a, 0);

2481

        assert_eq!(base.with_alpha_f32(1.0).a, 255);

2482

        // Out of range clamps rather than wrapping.

2483

        assert_eq!(base.with_alpha_f32(-1.0).a, 0);

2484

        assert_eq!(base.with_alpha_f32(-1e30).a, 0);

2485

        assert_eq!(base.with_alpha_f32(2.0).a, 255);

2486

        assert_eq!(base.with_alpha_f32(1e30).a, 255);

2487

        assert_eq!(base.with_alpha_f32(f32::INFINITY).a, 255);

2488

        assert_eq!(base.with_alpha_f32(f32::NEG_INFINITY).a, 0);

2489

        // `clamp` propagates NaN, and `NaN as u8` is 0 — fully transparent, not a panic.

2490

        assert_eq!(base.with_alpha_f32(f32::NAN).a, 0);

2491

        // RGB is never touched, whatever the alpha input.

2492

        for a in [-1.0, 0.0, 0.5, 1.0, 2.0, f32::NAN, f32::INFINITY] {

2493

            let c = base.with_alpha_f32(a);

2494

            assert_eq!((c.r, c.g, c.b), (1, 2, 3));

2495

2496

2497

2498

    #[test]

2499

    fn with_alpha_f32_truncates_rather_than_rounds() {

2500

        // 0.5 * 255.0 == 127.5, and `as u8` truncates => 127.

2501

        // NOTE: the `rgba(..., 0.5)` parser rounds the same value to 128

2502

        // (`parse_alpha_component` calls `.round()` first). See report.

2503

        assert_eq!(ColorU::rgb(0, 0, 0).with_alpha_f32(0.5).a, 127);

2504

2505

2506

    // =====================================================================

2507

    // numeric: interpolate / lighten / darken / mix

2508

    // =====================================================================

2509

2510

    #[test]

2511

    fn interpolate_endpoints_are_exact() {

2512

        for a in SAMPLES {

2513

            for b in SAMPLES {

2514

                assert_eq!(a.interpolate(&b, 0.0), a, "t=0 must return self");

2515

                assert_eq!(a.interpolate(&b, 1.0), b, "t=1 must return other");

2516

2517

2518

2519

2520

    #[test]

2521

    fn interpolate_midpoint_rounds_half_away_from_zero() {

2522

        // 0 + 255 * 0.5 = 127.5, roundf => 128.

2523

        assert_eq!(

2524

            ColorU::BLACK.interpolate(&ColorU::WHITE, 0.5),

2525

            ColorU::rgba(128, 128, 128, 255)

2526

);

2527

2528

2529

    #[test]

2530

    fn interpolate_is_symmetric_under_swapped_endpoints() {

2531

        for a in SAMPLES {

2532

            for b in SAMPLES {

2533

                assert_eq!(a.interpolate(&b, 0.25), b.interpolate(&a, 0.75));

2534

2535

2536

2537

2538

    #[test]

2539

    fn interpolate_nan_t_is_defined_and_does_not_panic() {

2540

        // t = NaN makes every channel NaN, and `NaN as u8` == 0.

2541

        for a in SAMPLES {

2542

            for b in SAMPLES {

2543

                assert_eq!(a.interpolate(&b, f32::NAN), ColorU::rgba(0, 0, 0, 0));

2544

2545

2546

2547

2548

    #[test]

2549

    fn interpolate_infinite_t_saturates_differing_channels() {

2550

        // Channels that differ run off to +/-inf and saturate at the u8 bounds.

2551

        let c = ColorU::rgba(0, 0, 0, 0).interpolate(&ColorU::WHITE, f32::INFINITY);

2552

        assert_eq!(c, ColorU::rgba(255, 255, 255, 255));

2553

        let c = ColorU::WHITE.interpolate(&ColorU::rgba(0, 0, 0, 0), f32::INFINITY);

2554

        assert_eq!(c, ColorU::rgba(0, 0, 0, 0));

2555

2556

2557

    #[test]

2558

    fn interpolate_infinite_t_zeroes_equal_channels() {

2559

        // Where a channel is EQUAL in both colors the delta is 0.0, and

2560

        // `0.0 * inf == NaN` => that channel collapses to 0 instead of

2561

        // staying put. Both endpoints here are alpha=255, so alpha => 0.

2562

        let c = ColorU::BLACK.interpolate(&ColorU::WHITE, f32::INFINITY);

2563

        assert_eq!(c, ColorU::rgba(255, 255, 255, 0));

2564

        // Interpolating a color with ITSELF at t=inf wipes it out entirely.

2565

        assert_eq!(

2566

            ColorU::RED.interpolate(&ColorU::RED, f32::INFINITY),

2567

            ColorU::rgba(0, 0, 0, 0)

2568

);

2569

2570

2571

    #[test]

2572

    fn interpolate_out_of_range_t_saturates_instead_of_wrapping() {

2573

        // Extrapolating past the endpoints overshoots the u8 range; the cast must

2574

        // saturate, not wrap (0 + 255*2 == 510 -> 255, not 254).

2575

        assert_eq!(

2576

            ColorU::BLACK.interpolate(&ColorU::WHITE, 2.0),

2577

            ColorU::rgba(255, 255, 255, 255)

2578

);

2579

        assert_eq!(

2580

            ColorU::WHITE.interpolate(&ColorU::BLACK, -1.0),

2581

            ColorU::rgba(255, 255, 255, 255)

2582

);

2583

        assert_eq!(

2584

            ColorU::WHITE.interpolate(&ColorU::BLACK, 2.0),

2585

            ColorU::rgba(0, 0, 0, 255)

2586

);

2587

        assert_eq!(

2588

            ColorU::BLACK.interpolate(&ColorU::WHITE, -1.0),

2589

            ColorU::rgba(0, 0, 0, 255)

2590

);

2591

        // And the whole sample matrix must stay panic-free and deterministic.

2592

        for t in [-1e30, -1.0, -0.5, 1.5, 2.0, 1e30] {

2593

            for a in SAMPLES {

2594

                for b in SAMPLES {

2595

                    assert_eq!(a.interpolate(&b, t), a.interpolate(&b, t));

2596

2597

2598

2599

2600

2601

    #[test]

2602

    fn lighten_and_darken_clamp_the_amount() {

2603

        let base = ColorU::rgba(128, 128, 128, 77);

2604

        // Below 0 clamps to 0 => unchanged.

2605

        assert_eq!(base.lighten(0.0), base);

2606

        assert_eq!(base.darken(0.0), base);

2607

        assert_eq!(base.lighten(-1.0), base);

2608

        assert_eq!(base.darken(-1e30), base);

2609

        assert_eq!(base.lighten(f32::NEG_INFINITY), base);

2610

        // Above 1 clamps to 1 => full white / full black, alpha preserved.

2611

        assert_eq!(base.lighten(1.0), ColorU::rgba(255, 255, 255, 77));

2612

        assert_eq!(base.lighten(2.0), ColorU::rgba(255, 255, 255, 77));

2613

        assert_eq!(base.lighten(f32::INFINITY), ColorU::rgba(255, 255, 255, 77));

2614

        assert_eq!(base.darken(1.0), ColorU::rgba(0, 0, 0, 77));

2615

        assert_eq!(base.darken(1e30), ColorU::rgba(0, 0, 0, 77));

2616

        assert_eq!(base.darken(f32::INFINITY), ColorU::rgba(0, 0, 0, 77));

2617

2618

2619

    #[test]

2620

    fn lighten_and_darken_always_preserve_alpha() {

2621

        for c in SAMPLES {

2622

            for amount in [-1.0, 0.0, 0.3, 1.0, 2.0, f32::NAN, f32::INFINITY] {

2623

                assert_eq!(c.lighten(amount).a, c.a);

2624

                assert_eq!(c.darken(amount).a, c.a);

2625

2626

2627

2628

2629

    #[test]

2630

    fn lighten_nan_amount_is_defined_and_does_not_panic() {

2631

        // `f32::clamp` propagates NaN, so the RGB channels collapse to 0 while

2632

        // alpha is explicitly restored afterwards.

2633

        let c = ColorU::rgba(255, 0, 0, 200);

2634

        assert_eq!(c.lighten(f32::NAN), ColorU::rgba(0, 0, 0, 200));

2635

        assert_eq!(c.darken(f32::NAN), ColorU::rgba(0, 0, 0, 200));

2636

2637

2638

    #[test]

2639

    fn mix_clamps_ratio_to_the_endpoints() {

2640

        let a = ColorU::rgba(10, 20, 30, 40);

2641

        let b = ColorU::rgba(200, 210, 220, 230);

2642

        assert_eq!(a.mix(&b, 0.0), a);

2643

        assert_eq!(a.mix(&b, 1.0), b);

2644

        assert_eq!(a.mix(&b, -1.0), a);

2645

        assert_eq!(a.mix(&b, f32::NEG_INFINITY), a);

2646

        assert_eq!(a.mix(&b, 2.0), b);

2647

        assert_eq!(a.mix(&b, 1e30), b);

2648

        assert_eq!(a.mix(&b, f32::INFINITY), b);

2649

2650

2651

    #[test]

2652

    fn mix_nan_ratio_is_defined_and_does_not_panic() {

2653

        // Unlike lighten/darken, mix does NOT restore alpha => fully transparent.

2654

        assert_eq!(

2655

            ColorU::RED.mix(&ColorU::BLUE, f32::NAN),

2656

            ColorU::rgba(0, 0, 0, 0)

2657

);

2658

2659

2660

    // =====================================================================

2661

    // numeric: srgb_to_linear (private)

2662

    // =====================================================================

2663

2664

    #[test]

2665

    fn srgb_to_linear_endpoints_and_monotonicity() {

2666

        assert_eq!(ColorU::srgb_to_linear(0.0), 0.0);

2667

        assert!((ColorU::srgb_to_linear(1.0) - 1.0).abs() < 1e-5);

2668

        // Monotonically non-decreasing over the whole 8-bit ramp.

2669

        let mut prev = f32::NEG_INFINITY;

2670

        for i in 0..=255u16 {

2671

            let v = ColorU::srgb_to_linear(f32::from(i) / 255.0);

2672

            assert!(v >= prev, "srgb_to_linear not monotonic at {i}");

2673

            assert!((0.0..=1.0).contains(&v), "out of range at {i}: {v}");

2674

            prev = v;

2675

2676

2677

2678

    #[test]

2679

    fn srgb_to_linear_handles_the_piecewise_boundary() {

2680

        // The branch flips at c == 0.03928 (linear below, gamma above).

2681

        let below = ColorU::srgb_to_linear(0.03928);

2682

        assert!((below - 0.03928 / 12.92).abs() < 1e-9);

2683

        let above = ColorU::srgb_to_linear(0.03929);

2684

        assert!(above > below, "must not go backwards across the boundary");

2685

2686

2687

    #[test]

2688

    fn srgb_to_linear_nan_inf_and_negative_do_not_panic() {

2689

        assert!(ColorU::srgb_to_linear(f32::NAN).is_nan());

2690

        assert_eq!(ColorU::srgb_to_linear(f32::INFINITY), f32::INFINITY);

2691

        assert_eq!(ColorU::srgb_to_linear(f32::NEG_INFINITY), f32::NEG_INFINITY);

2692

        // Negative inputs take the linear branch and stay negative (deterministic).

2693

        assert!(ColorU::srgb_to_linear(-1.0) < 0.0);

2694

        assert_eq!(ColorU::srgb_to_linear(-0.0), -0.0);

2695

2696

2697

    // =====================================================================

2698

    // getters: luminance / relative_luminance / is_light / is_dark

2699

    // =====================================================================

2700

2701

    #[test]

2702

    fn luminance_endpoints_and_range() {

2703

        assert!((ColorU::BLACK.luminance() - 0.0).abs() < 1e-6);

2704

        assert!((ColorU::WHITE.luminance() - 1.0).abs() < 1e-6);

2705

        for r in (0..=255u16).step_by(17) {

2706

            for g in (0..=255u16).step_by(51) {

2707

                for b in (0..=255u16).step_by(85) {

2708

                    #[allow(clippy::cast_possible_truncation)]

2709

                    let l = ColorU::rgb(r as u8, g as u8, b as u8).luminance();

2710

                    assert!(

2711

                        l.is_finite() && (-1e-6..=1.000_001).contains(&l),

2712

                        "luminance {l}"

2713

);

2714

2715

2716

2717

2718

2719

    #[test]

2720

    fn luminance_ignores_alpha() {

2721

        for a in [0u8, 1, 128, 254, 255] {

2722

            assert!(

2723

                (ColorU::rgba(10, 20, 30, a).luminance()

2724

                    - ColorU::rgba(10, 20, 30, 255).luminance())

2725

                .abs()

2726

                    < 1e-9

2727

);

2728

2729

2730

2731

    #[test]

2732

    fn relative_luminance_endpoints_and_range() {

2733

        assert!((ColorU::BLACK.relative_luminance() - 0.0).abs() < 1e-6);

2734

        assert!((ColorU::WHITE.relative_luminance() - 1.0).abs() < 1e-6);

2735

        for i in 0..=255u16 {

2736

            #[allow(clippy::cast_possible_truncation)]

2737

            let l = ColorU::rgb(i as u8, i as u8, i as u8).relative_luminance();

2738

            assert!(l.is_finite(), "non-finite relative_luminance at {i}");

2739

            assert!((-1e-6..=1.000_001).contains(&l), "out of range at {i}: {l}");

2740

2741

2742

2743

    #[test]

2744

    fn relative_luminance_is_monotonic_along_the_gray_ramp() {

2745

        let mut prev = f32::NEG_INFINITY;

2746

        for i in 0..=255u16 {

2747

            #[allow(clippy::cast_possible_truncation)]

2748

            let l = ColorU::rgb(i as u8, i as u8, i as u8).relative_luminance();

2749

            assert!(l >= prev, "gray ramp not monotonic at {i}");

2750

            prev = l;

2751

2752

2753

2754

    #[test]

2755

    fn is_light_and_is_dark_are_exact_complements() {

2756

        // The two predicates split at exactly 0.5 with no overlap and no gap,

2757

        // for every single 8-bit color on the gray ramp plus the samples.

2758

        for i in 0..=255u16 {

2759

            #[allow(clippy::cast_possible_truncation)]

2760

            let c = ColorU::rgb(i as u8, i as u8, i as u8);

2761

            assert_ne!(c.is_light(), c.is_dark(), "not complementary at {i}");

2762

2763

        for c in SAMPLES {

2764

            assert_ne!(c.is_light(), c.is_dark());

2765

2766

2767

2768

    #[test]

2769

    fn is_light_and_is_dark_known_values() {

2770

        assert!(ColorU::WHITE.is_light());

2771

        assert!(!ColorU::WHITE.is_dark());

2772

        assert!(ColorU::BLACK.is_dark());

2773

        assert!(!ColorU::BLACK.is_light());

2774

        // Default (BLACK) is dark.

2775

        assert!(ColorU::default().is_dark());

2776

        // Mid gray is "dark" under WCAG relative luminance (~0.216, not 0.5).

2777

        assert!(ColorU::rgb(128, 128, 128).is_dark());

2778

2779

2780

    // =====================================================================

2781

    // contrast: contrast_ratio / meets_wcag_* / best_contrast_text

2782

    // =====================================================================

2783

2784

    #[test]

2785

    fn contrast_ratio_is_symmetric() {

2786

        for a in SAMPLES {

2787

            for b in SAMPLES {

2788

                let ab = a.contrast_ratio(&b);

2789

                let ba = b.contrast_ratio(&a);

2790

                assert!((ab - ba).abs() < 1e-6, "asymmetric: {ab} vs {ba}");

2791

2792

2793

2794

2795

    #[test]

2796

    fn contrast_ratio_stays_within_1_and_21() {

2797

        for a in SAMPLES {

2798

            for b in SAMPLES {

2799

                let r = a.contrast_ratio(&b);

2800

                assert!(r.is_finite(), "non-finite contrast ratio");

2801

                assert!(

2802

                    (0.999..=21.001).contains(&r),

2803

                    "contrast ratio out of range: {r}"

2804

);

2805

2806

            // Self-contrast is exactly 1.

2807

            assert!((a.contrast_ratio(&a) - 1.0).abs() < 1e-6);

2808

2809

        // Max contrast (fp gives 20.999998, not a clean 21.0).

2810

        let max = ColorU::BLACK.contrast_ratio(&ColorU::WHITE);

2811

        assert!((max - 21.0).abs() < 0.01, "black/white contrast was {max}");

2812

2813

2814

    #[test]

2815

    fn meets_wcag_thresholds_agree_with_contrast_ratio() {

2816

        for a in SAMPLES {

2817

            for b in SAMPLES {

2818

                let r = a.contrast_ratio(&b);

2819

                assert_eq!(a.meets_wcag_aa(&b), r >= 4.5);

2820

                assert_eq!(a.meets_wcag_aa_large(&b), r >= 3.0);

2821

                assert_eq!(a.meets_wcag_aaa(&b), r >= 7.0);

2822

                assert_eq!(a.meets_wcag_aaa_large(&b), r >= 4.5);

2823

2824

2825

2826

2827

    #[test]

2828

    fn meets_wcag_known_true_and_false() {

2829

        assert!(ColorU::BLACK.meets_wcag_aa(&ColorU::WHITE));

2830

        assert!(ColorU::BLACK.meets_wcag_aaa(&ColorU::WHITE));

2831

        assert!(ColorU::WHITE.meets_wcag_aa_large(&ColorU::BLACK));

2832

        // A color has no contrast against itself.

2833

        assert!(!ColorU::RED.meets_wcag_aa(&ColorU::RED));

2834

        assert!(!ColorU::RED.meets_wcag_aa_large(&ColorU::RED));

2835

        assert!(!ColorU::WHITE.meets_wcag_aaa(&ColorU::WHITE));

2836

2837

2838

    #[test]

2839

    fn best_contrast_text_only_ever_returns_black_or_white() {

2840

        for c in SAMPLES {

2841

            let t = c.best_contrast_text();

2842

            assert!(t == ColorU::WHITE || t == ColorU::BLACK, "got {t:?}");

2843

            // contrast_text is documented as an alias.

2844

            assert_eq!(c.contrast_text(), t);

2845

2846

        for i in 0..=255u16 {

2847

            #[allow(clippy::cast_possible_truncation)]

2848

            let c = ColorU::rgb(i as u8, i as u8, i as u8);

2849

            let t = c.best_contrast_text();

2850

            assert!(t == ColorU::WHITE || t == ColorU::BLACK);

2851

2852

2853

2854

    #[test]

2855

    fn best_contrast_text_picks_the_higher_contrast_option() {

2856

        assert_eq!(ColorU::WHITE.best_contrast_text(), ColorU::BLACK);

2857

        assert_eq!(ColorU::BLACK.best_contrast_text(), ColorU::WHITE);

2858

        for c in SAMPLES {

2859

            let t = c.best_contrast_text();

2860

            let other = if t == ColorU::WHITE {

2861

                ColorU::BLACK

2862

            } else {

2863

                ColorU::WHITE

2864

};

2865

            assert!(

2866

                c.contrast_ratio(&t) >= c.contrast_ratio(&other),

2867

                "{c:?} picked the lower-contrast text color"

2868

);

2869

2870

2871

2872

    // =====================================================================

2873

    // numeric: ensure_contrast (binary search — must terminate + saturate)

2874

    // =====================================================================

2875

2876

    #[test]

2877

    fn ensure_contrast_returns_self_when_already_compliant() {

2878

        // 21:1 already, nothing to do.

2879

        assert_eq!(

2880

            ColorU::BLACK.ensure_contrast(&ColorU::WHITE, 4.5),

2881

            ColorU::BLACK

2882

);

2883

        let gray = ColorU::rgb(128, 128, 128);

2884

        // 5.3:1 against black already clears 4.5.

2885

        assert_eq!(gray.ensure_contrast(&ColorU::BLACK, 4.5), gray);

2886

2887

2888

    #[test]

2889

    fn ensure_contrast_actually_reaches_the_requested_ratio() {

2890

        let gray = ColorU::rgb(128, 128, 128);

2891

        let fixed = gray.ensure_contrast(&ColorU::WHITE, 4.5);

2892

        assert!(

2893

            fixed.contrast_ratio(&ColorU::WHITE) >= 4.5,

2894

            "adjusted color {fixed:?} still fails 4.5:1"

2895

);

2896

        // Darkening against a light background must not make it lighter.

2897

        assert!(fixed.r <= gray.r && fixed.g <= gray.g && fixed.b <= gray.b);

2898

2899

2900

    #[test]

2901

    fn ensure_contrast_degenerate_min_ratios_return_self() {

2902

        let gray = ColorU::rgb(128, 128, 128);

2903

        // <= current ratio: early return.

2904

        assert_eq!(gray.ensure_contrast(&ColorU::WHITE, 0.0), gray);

2905

        assert_eq!(gray.ensure_contrast(&ColorU::WHITE, -1.0), gray);

2906

        assert_eq!(

2907

            gray.ensure_contrast(&ColorU::WHITE, f32::NEG_INFINITY),

2908

            gray

2909

);

2910

        // Unsatisfiable / NaN: every comparison is false, so `result` never

2911

        // moves off `*self`. Terminates (fixed 16 iterations), never hangs.

2912

        assert_eq!(gray.ensure_contrast(&ColorU::WHITE, f32::INFINITY), gray);

2913

        assert_eq!(gray.ensure_contrast(&ColorU::WHITE, f32::NAN), gray);

2914

        assert_eq!(gray.ensure_contrast(&ColorU::WHITE, 1e30), gray);

2915

2916

2917

    #[test]

2918

    fn ensure_contrast_terminates_for_every_sample_pair() {

2919

        for c in SAMPLES {

2920

            for bg in SAMPLES {

2921

                for min in [1.0, 3.0, 4.5, 7.0, 21.0, 25.0] {

2922

                    let out = c.ensure_contrast(&bg, min);

2923

                    // Alpha is carried through lighten/darken untouched.

2924

                    assert_eq!(out.a, c.a);

2925

2926

2927

2928

2929

2930

    // =====================================================================

2931

    // APCA

2932

    // =====================================================================

2933

2934

    #[test]

2935

    fn apca_contrast_sign_encodes_polarity() {

2936

        let dark_on_light = ColorU::BLACK.apca_contrast(&ColorU::WHITE);

2937

        let light_on_dark = ColorU::WHITE.apca_contrast(&ColorU::BLACK);

2938

        assert!(dark_on_light > 0.0, "black-on-white should be positive");

2939

        assert!(light_on_dark < 0.0, "white-on-black should be negative");

2940

        assert!(dark_on_light.is_finite() && light_on_dark.is_finite());

2941

2942

2943

    #[test]

2944

    fn apca_contrast_of_a_color_against_itself_is_zero() {

2945

        for c in SAMPLES {

2946

            assert_eq!(c.apca_contrast(&c), 0.0, "{c:?} vs itself");

2947

2948

2949

2950

    #[test]

2951

    fn apca_contrast_is_finite_for_every_sample_pair() {

2952

        for a in SAMPLES {

2953

            for b in SAMPLES {

2954

                assert!(a.apca_contrast(&b).is_finite(), "{a:?} on {b:?}");

2955

2956

2957

2958

2959

    #[test]

2960

    fn meets_apca_thresholds_agree_with_apca_contrast() {

2961

        for a in SAMPLES {

2962

            for b in SAMPLES {

2963

                let lc = libm::fabsf(a.apca_contrast(&b));

2964

                assert_eq!(a.meets_apca_body(&b), lc >= 60.0);

2965

                assert_eq!(a.meets_apca_large(&b), lc >= 45.0);

2966

2967

2968

        assert!(ColorU::BLACK.meets_apca_body(&ColorU::WHITE));

2969

        assert!(ColorU::BLACK.meets_apca_large(&ColorU::WHITE));

2970

        assert!(!ColorU::RED.meets_apca_body(&ColorU::RED));

2971

        assert!(!ColorU::RED.meets_apca_large(&ColorU::RED));

2972

2973

2974

    // =====================================================================

2975

    // getters / predicates: hover_variant, active_variant, invert,

2976

    //                       to_grayscale, has_alpha, to_hash

2977

    // =====================================================================

2978

2979

    #[test]

2980

    fn hover_and_active_variants_preserve_alpha_and_never_panic() {

2981

        for c in SAMPLES {

2982

            assert_eq!(c.hover_variant().a, c.a);

2983

            assert_eq!(c.active_variant().a, c.a);

2984

2985

        // Light colors get darker, dark colors get lighter.

2986

        assert!(ColorU::WHITE.hover_variant().r < 255);

2987

        assert!(ColorU::BLACK.hover_variant().r > 0);

2988

        assert!(ColorU::WHITE.active_variant().r < ColorU::WHITE.hover_variant().r);

2989

2990

2991

    #[test]

2992

    fn invert_is_its_own_inverse() {

2993

        for c in SAMPLES {

2994

            assert_eq!(c.invert().invert(), c);

2995

            assert_eq!(c.invert().a, c.a, "invert must keep alpha");

2996

2997

        assert_eq!(ColorU::BLACK.invert(), ColorU::WHITE);

2998

        assert_eq!(ColorU::WHITE.invert(), ColorU::BLACK);

2999

3000

3001

    #[test]

3002

    fn invert_does_not_underflow_at_the_channel_bounds() {

3003

        // `255 - self.r` on u8 would panic in debug on underflow; it cannot,

3004

        // but pin the boundary values anyway.

3005

        assert_eq!(

3006

            ColorU::rgba(0, 0, 0, 0).invert(),

3007

            ColorU::rgba(255, 255, 255, 0)

3008

);

3009

        assert_eq!(

3010

            ColorU::rgba(255, 255, 255, 255).invert(),

3011

            ColorU::rgba(0, 0, 0, 255)

3012

);

3013

3014

3015

    #[test]

3016

    fn to_grayscale_produces_equal_channels_and_keeps_alpha() {

3017

        for c in SAMPLES {

3018

            let g = c.to_grayscale();

3019

            assert_eq!(g.r, g.g);

3020

            assert_eq!(g.g, g.b);

3021

            assert_eq!(g.a, c.a);

3022

3023

3024

3025

    #[test]

3026

    fn to_grayscale_boundary_values() {

3027

        assert_eq!(ColorU::BLACK.to_grayscale(), ColorU::BLACK);

3028

        assert_eq!(ColorU::WHITE.to_grayscale(), ColorU::WHITE);

3029

        assert_eq!(

3030

            ColorU::rgb(128, 128, 128).to_grayscale(),

3031

            ColorU::rgb(128, 128, 128)

3032

);

3033

        // An already-gray color is (near enough) a fixed point of to_grayscale:

3034

        // the BT.601 weights sum to 1.0, so only the truncating cast can shave

3035

        // off at most one level.

3036

        for i in 0..=255u16 {

3037

            #[allow(clippy::cast_possible_truncation)]

3038

            let c = ColorU::rgb(i as u8, i as u8, i as u8);

3039

            let drift = i32::from(c.r) - i32::from(c.to_grayscale().r);

3040

            assert!((0..=1).contains(&drift), "gray {i} drifted by {drift}");

3041

3042

3043

3044

    #[test]

3045

    fn has_alpha_is_true_for_everything_but_255() {

3046

        assert!(!ColorU::rgba(0, 0, 0, 255).has_alpha());

3047

        assert!(!ColorU::WHITE.has_alpha());

3048

        assert!(ColorU::rgba(0, 0, 0, 254).has_alpha());

3049

        assert!(ColorU::TRANSPARENT.has_alpha());

3050

        for a in 0..=u8::MAX {

3051

            assert_eq!(ColorU::rgba(1, 2, 3, a).has_alpha(), a != 255);

3052

3053

3054

3055

    #[test]

3056

    fn to_hash_is_always_nine_lowercase_chars() {

3057

        assert_eq!(ColorU::RED.to_hash(), "#ff0000ff");

3058

        assert_eq!(ColorU::TRANSPARENT.to_hash(), "#00000000");

3059

        assert_eq!(ColorU::rgba(1, 2, 3, 4).to_hash(), "#01020304");

3060

        assert_eq!(ColorU::WHITE.to_hash(), "#ffffffff");

3061

        for c in SAMPLES {

3062

            let h = c.to_hash();

3063

            assert_eq!(h.len(), 9, "{h} is not 9 bytes");

3064

            assert!(h.starts_with('#'));

3065

            assert!(

3066

                h[1..]

3067

                    .chars()

3068

                    .all(|ch| ch.is_ascii_hexdigit() && !ch.is_ascii_uppercase()),

3069

                "{h} is not lowercase hex"

3070

);

3071

3072

3073

3074

    // =====================================================================

3075

    // serializer: Display for ColorU / ColorF

3076

    // =====================================================================

3077

3078

    #[test]

3079

    fn coloru_display_is_well_formed() {

3080

        assert_eq!(format!("{}", ColorU::RED), "rgba(255, 0, 0, 1)");

3081

        assert_eq!(format!("{}", ColorU::TRANSPARENT), "rgba(0, 0, 0, 0)");

3082

        assert_eq!(format!("{}", ColorU::default()), "rgba(0, 0, 0, 1)");

3083

        // Alpha is normalized to 0.0..=1.0.

3084

        assert_eq!(

3085

            format!("{}", ColorU::rgba(1, 2, 3, 128)),

3086

            "rgba(1, 2, 3, 0.5019608)"

3087

);

3088

        for c in SAMPLES {

3089

            let s = format!("{c}");

3090

            assert!(s.starts_with("rgba(") && s.ends_with(')') && s.len() > 6);

3091

3092

3093

3094

    #[test]

3095

    fn colorf_display_survives_nan_and_inf() {

3096

        assert_eq!(format!("{}", ColorF::BLACK), "rgba(0, 0, 0, 1)");

3097

        assert_eq!(format!("{}", ColorF::WHITE), "rgba(255, 255, 255, 1)");

3098

        assert_eq!(format!("{}", ColorF::TRANSPARENT), "rgba(0, 0, 0, 0)");

3099

        assert_eq!(

3100

            format!("{}", ColorF::default()),

3101

            format!("{}", ColorF::BLACK)

3102

);

3103

3104

        let nan = ColorF {

3105

            r: f32::NAN,

3106

            g: f32::NAN,

3107

            b: f32::NAN,

3108

            a: f32::NAN,

3109

};

3110

        assert_eq!(format!("{nan}"), "rgba(NaN, NaN, NaN, NaN)");

3111

3112

        let inf = ColorF {

3113

            r: f32::INFINITY,

3114

            g: f32::NEG_INFINITY,

3115

            b: f32::MAX,

3116

            a: f32::INFINITY,

3117

};

3118

        let s = format!("{inf}");

3119

        assert!(

3120

            s.starts_with("rgba(inf, -inf, ") && s.ends_with(", inf)"),

3121

            "{s}"

3122

);

3123

3124

3125

    // =====================================================================

3126

    // round-trip: ColorU <-> ColorF, to_hash -> parse, Display -> parse

3127

    // =====================================================================

3128

3129

    #[test]

3130

    fn coloru_to_colorf_and_back_is_lossless_for_all_256_channel_values() {

3131

        for i in 0..=255u16 {

3132

            #[allow(clippy::cast_possible_truncation)]

3133

            let c = ColorU::rgba(i as u8, (255 - i) as u8, i as u8, (255 - i) as u8);

3134

            let f: ColorF = c.into();

3135

            let back: ColorU = f.into();

3136

            assert_eq!(back, c, "round-trip lost information at {i}");

3137

3138

3139

3140

    #[test]

3141

    fn colorf_to_coloru_clamps_out_of_range_channels() {

3142

        // > 1.0 is clamped by `.min(1.0)`.

3143

        let over = ColorF {

3144

            r: 2.0,

3145

            g: 1e30,

3146

            b: f32::INFINITY,

3147

            a: 1.5,

3148

};

3149

        assert_eq!(ColorU::from(over), ColorU::rgba(255, 255, 255, 255));

3150

        // < 0.0 is NOT clamped by `.min`, but `as u8` saturates it to 0 anyway.

3151

        let under = ColorF {

3152

            r: -1.0,

3153

            g: -1e30,

3154

            b: f32::NEG_INFINITY,

3155

            a: -0.5,

3156

};

3157

        assert_eq!(ColorU::from(under), ColorU::rgba(0, 0, 0, 0));

3158

3159

3160

    #[test]

3161

    fn colorf_to_coloru_maps_nan_channels_to_255() {

3162

        // `f32::min` returns the NON-NaN operand, so `NaN.min(1.0) == 1.0`,

3163

        // and a NaN channel comes out fully saturated rather than 0.

3164

        let nan = ColorF {

3165

            r: f32::NAN,

3166

            g: 0.0,

3167

            b: 0.0,

3168

            a: f32::NAN,

3169

};

3170

        assert_eq!(ColorU::from(nan), ColorU::rgba(255, 0, 0, 255));

3171

3172

3173

    #[cfg(feature = "parser")]

3174

    #[test]

3175

    fn to_hash_round_trips_through_the_parser() {

3176

        assert_eq!(

3177

            parse_css_color(&ColorU::RED.to_hash()).unwrap(),

3178

            ColorU::RED

3179

);

3180

        for r in (0..=255u16).step_by(51) {

3181

            for g in (0..=255u16).step_by(51) {

3182

                for b in (0..=255u16).step_by(85) {

3183

                    for a in (0..=255u16).step_by(85) {

3184

                        #[allow(clippy::cast_possible_truncation)]

3185

                        let c = ColorU::rgba(r as u8, g as u8, b as u8, a as u8);

3186

                        let encoded = c.to_hash();

3187

                        let decoded = parse_css_color(&encoded)

3188

                            .unwrap_or_else(|e| panic!("{encoded} failed to parse: {e}"));

3189

                        assert_eq!(decoded, c, "{encoded} decoded to the wrong color");

3190

3191

3192

3193

3194

3195

3196

    #[cfg(feature = "parser")]

3197

    #[test]

3198

    fn coloru_display_round_trips_through_the_parser() {

3199

        // Display emits `rgba(r, g, b, a/255)`, which parse_css_color accepts.

3200

        for a in 0..=255u16 {

3201

            #[allow(clippy::cast_possible_truncation)]

3202

            let c = ColorU::rgba(13, 110, 253, a as u8);

3203

            let encoded = format!("{c}");

3204

            let decoded = parse_css_color(&encoded)

3205

                .unwrap_or_else(|e| panic!("{encoded} failed to parse: {e}"));

3206

            assert_eq!(decoded, c, "{encoded} decoded to the wrong color");

3207

3208

        for c in SAMPLES {

3209

            assert_eq!(parse_css_color(&format!("{c}")).unwrap(), c);

3210

3211

3212

3213

    #[cfg(feature = "parser")]

3214

    #[test]

3215

    fn system_color_ref_css_str_round_trips_for_every_variant() {

3216

        let all = [

3217

            SystemColorRef::Text,

3218

            SystemColorRef::Background,

3219

            SystemColorRef::Accent,

3220

            SystemColorRef::AccentText,

3221

            SystemColorRef::ButtonFace,

3222

            SystemColorRef::ButtonText,

3223

            SystemColorRef::WindowBackground,

3224

            SystemColorRef::SelectionBackground,

3225

            SystemColorRef::SelectionText,

3226

];

3227

        for variant in all {

3228

            let encoded = variant.as_css_str();

3229

            assert!(encoded.starts_with("system:"), "{encoded}");

3230

            assert_eq!(

3231

                parse_color_or_system(encoded).unwrap(),

3232

                ColorOrSystem::System(variant),

3233

                "{encoded} did not round-trip"

3234

);

3235

3236

3237

3238

    // =====================================================================

3239

    // ColorOrSystem / SystemColorRef

3240

    // =====================================================================

3241

3242

    #[test]

3243

    fn color_or_system_constructors_and_fallbacks() {

3244

        let c = ColorOrSystem::color(ColorU::RED);

3245

        assert_eq!(c, ColorOrSystem::Color(ColorU::RED));

3246

        assert_eq!(c.to_color_u_with_fallback(ColorU::BLUE), ColorU::RED);

3247

        assert_eq!(c.to_color_u_default(), ColorU::RED);

3248

3249

        let s = ColorOrSystem::system(SystemColorRef::Accent);

3250

        assert_eq!(s, ColorOrSystem::System(SystemColorRef::Accent));

3251

        // A system ref has no concrete value, so the fallback wins.

3252

        assert_eq!(s.to_color_u_with_fallback(ColorU::BLUE), ColorU::BLUE);

3253

        assert_eq!(s.to_color_u_default(), ColorU::rgba(128, 128, 128, 255));

3254

3255

        // Default is opaque black, and From<ColorU> agrees with ::color().

3256

        assert_eq!(

3257

            ColorOrSystem::default(),

3258

            ColorOrSystem::Color(ColorU::BLACK)

3259

);

3260

        assert_eq!(

3261

            ColorOrSystem::from(ColorU::RED),

3262

            ColorOrSystem::color(ColorU::RED)

3263

);

3264

3265

3266

    #[test]

3267

    fn system_color_ref_resolve_falls_back_when_unset() {

3268

        use crate::system::SystemColors;

3269

3270

        let empty = SystemColors::default();

3271

        let all = [

3272

            SystemColorRef::Text,

3273

            SystemColorRef::Background,

3274

            SystemColorRef::Accent,

3275

            SystemColorRef::AccentText,

3276

            SystemColorRef::ButtonFace,

3277

            SystemColorRef::ButtonText,

3278

            SystemColorRef::WindowBackground,

3279

            SystemColorRef::SelectionBackground,

3280

            SystemColorRef::SelectionText,

3281

];

3282

        for variant in all {

3283

            assert_eq!(

3284

                variant.resolve(&empty, ColorU::RED),

3285

                ColorU::RED,

3286

                "{variant:?}"

3287

);

3288

            assert_eq!(

3289

                ColorOrSystem::System(variant).resolve(&empty, ColorU::RED),

3290

                ColorU::RED

3291

);

3292

3293

        // A concrete color ignores both the SystemColors and the fallback.

3294

        assert_eq!(

3295

            ColorOrSystem::Color(ColorU::BLUE).resolve(&empty, ColorU::RED),

3296

            ColorU::BLUE

3297

);

3298

3299

3300

    // =====================================================================

3301

    // palettes: shade is a `usize`, so every value must land somewhere

3302

    // =====================================================================

3303

3304

    #[test]

3305

    fn palette_shades_are_total_over_usize_and_always_opaque() {

3306

        type Palette = fn(usize) -> ColorU;

3307

        const PALETTES: [Palette; 12] = [

3308

            ColorU::strawberry,

3309

            ColorU::palette_orange,

3310

            ColorU::banana,

3311

            ColorU::palette_lime,

3312

            ColorU::mint,

3313

            ColorU::blueberry,

3314

            ColorU::grape,

3315

            ColorU::bubblegum,

3316

            ColorU::cocoa,

3317

            ColorU::palette_silver,

3318

            ColorU::slate,

3319

            ColorU::dark,

3320

];

3321

        for p in PALETTES {

3322

            for shade in [

3323

0,

3324

1,

3325

                100,

3326

                200,

3327

                201,

3328

                300,

3329

                400,

3330

                401,

3331

                500,

3332

                600,

3333

                601,

3334

                700,

3335

                800,

3336

                801,

3337

                900,

3338

                1000,

3339

                usize::MAX,

3340

] {

3341

                assert_eq!(p(shade).a, 255, "shade {shade} was not opaque");

3342

3343

            // Every out-of-band shade collapses into the 900 bucket.

3344

            assert_eq!(p(usize::MAX), p(900));

3345

            assert_eq!(p(801), p(900));

3346

            // The documented buckets are distinct at their boundaries.

3347

            assert_eq!(p(0), p(200));

3348

            assert_ne!(p(200), p(201));

3349

            assert_ne!(p(400), p(401));

3350

            assert_ne!(p(600), p(601));

3351

            assert_ne!(p(800), p(801));

3352

3353

3354

3355

    #[test]

3356

    fn palette_known_values() {

3357

        assert_eq!(ColorU::strawberry(100), ColorU::rgb(0xff, 0x8c, 0x82));

3358

        assert_eq!(ColorU::strawberry(900), ColorU::rgb(0x7a, 0x00, 0x00));

3359

        assert_eq!(ColorU::dark(900), ColorU::BLACK);

3360

        assert_eq!(ColorU::dark(usize::MAX), ColorU::BLACK);

3361

3362

3363

    // =====================================================================

3364

    // named / themed constructors: every one must be a valid opaque color

3365

    // =====================================================================

3366

3367

    #[test]

3368

    fn named_constructors_match_their_constants() {

3369

        assert_eq!(ColorU::red(), ColorU::RED);

3370

        assert_eq!(ColorU::green(), ColorU::GREEN);

3371

        assert_eq!(ColorU::blue(), ColorU::BLUE);

3372

        assert_eq!(ColorU::white(), ColorU::WHITE);

3373

        assert_eq!(ColorU::black(), ColorU::BLACK);

3374

        assert_eq!(ColorU::transparent(), ColorU::TRANSPARENT);

3375

        assert_eq!(ColorU::yellow(), ColorU::YELLOW);

3376

        assert_eq!(ColorU::cyan(), ColorU::CYAN);

3377

        assert_eq!(ColorU::magenta(), ColorU::MAGENTA);

3378

        assert_eq!(ColorU::orange(), ColorU::ORANGE);

3379

        assert_eq!(ColorU::pink(), ColorU::PINK);

3380

        assert_eq!(ColorU::purple(), ColorU::PURPLE);

3381

        assert_eq!(ColorU::brown(), ColorU::BROWN);

3382

        assert_eq!(ColorU::gray(), ColorU::GRAY);

3383

        assert_eq!(ColorU::light_gray(), ColorU::LIGHT_GRAY);

3384

        assert_eq!(ColorU::dark_gray(), ColorU::DARK_GRAY);

3385

        assert_eq!(ColorU::navy(), ColorU::NAVY);

3386

        assert_eq!(ColorU::teal(), ColorU::TEAL);

3387

        assert_eq!(ColorU::olive(), ColorU::OLIVE);

3388

        assert_eq!(ColorU::maroon(), ColorU::MAROON);

3389

        assert_eq!(ColorU::lime(), ColorU::LIME);

3390

        assert_eq!(ColorU::aqua(), ColorU::AQUA);

3391

        assert_eq!(ColorU::silver(), ColorU::SILVER);

3392

        assert_eq!(ColorU::fuchsia(), ColorU::FUCHSIA);

3393

        assert_eq!(ColorU::indigo(), ColorU::INDIGO);

3394

        assert_eq!(ColorU::gold(), ColorU::GOLD);

3395

        assert_eq!(ColorU::coral(), ColorU::CORAL);

3396

        assert_eq!(ColorU::salmon(), ColorU::SALMON);

3397

        assert_eq!(ColorU::turquoise(), ColorU::TURQUOISE);

3398

        assert_eq!(ColorU::violet(), ColorU::VIOLET);

3399

        assert_eq!(ColorU::crimson(), ColorU::CRIMSON);

3400

        assert_eq!(ColorU::chocolate(), ColorU::CHOCOLATE);

3401

        assert_eq!(ColorU::sky_blue(), ColorU::SKY_BLUE);

3402

        assert_eq!(ColorU::forest_green(), ColorU::FOREST_GREEN);

3403

        assert_eq!(ColorU::sea_green(), ColorU::SEA_GREEN);

3404

        assert_eq!(ColorU::slate_gray(), ColorU::SLATE_GRAY);

3405

        assert_eq!(ColorU::midnight_blue(), ColorU::MIDNIGHT_BLUE);

3406

        assert_eq!(ColorU::dark_red(), ColorU::DARK_RED);

3407

        assert_eq!(ColorU::dark_green(), ColorU::DARK_GREEN);

3408

        assert_eq!(ColorU::dark_blue(), ColorU::DARK_BLUE);

3409

        assert_eq!(ColorU::light_blue(), ColorU::LIGHT_BLUE);

3410

        assert_eq!(ColorU::light_green(), ColorU::LIGHT_GREEN);

3411

        assert_eq!(ColorU::light_yellow(), ColorU::LIGHT_YELLOW);

3412

        assert_eq!(ColorU::light_pink(), ColorU::LIGHT_PINK);

3413

3414

3415

    #[test]

3416

    fn every_named_constructor_except_transparent_is_opaque() {

3417

        type Ctor = fn() -> ColorU;

3418

        const CTORS: [Ctor; 43] = [

3419

            ColorU::red,

3420

            ColorU::green,

3421

            ColorU::blue,

3422

            ColorU::white,

3423

            ColorU::black,

3424

            ColorU::yellow,

3425

            ColorU::cyan,

3426

            ColorU::magenta,

3427

            ColorU::orange,

3428

            ColorU::pink,

3429

            ColorU::purple,

3430

            ColorU::brown,

3431

            ColorU::gray,

3432

            ColorU::light_gray,

3433

            ColorU::dark_gray,

3434

            ColorU::navy,

3435

            ColorU::teal,

3436

            ColorU::olive,

3437

            ColorU::maroon,

3438

            ColorU::lime,

3439

            ColorU::aqua,

3440

            ColorU::silver,

3441

            ColorU::fuchsia,

3442

            ColorU::indigo,

3443

            ColorU::gold,

3444

            ColorU::coral,

3445

            ColorU::salmon,

3446

            ColorU::turquoise,

3447

            ColorU::violet,

3448

            ColorU::crimson,

3449

            ColorU::chocolate,

3450

            ColorU::sky_blue,

3451

            ColorU::forest_green,

3452

            ColorU::sea_green,

3453

            ColorU::slate_gray,

3454

            ColorU::midnight_blue,

3455

            ColorU::dark_red,

3456

            ColorU::dark_green,

3457

            ColorU::dark_blue,

3458

            ColorU::light_blue,

3459

            ColorU::light_green,

3460

            ColorU::light_yellow,

3461

            ColorU::light_pink,

3462

];

3463

        for ctor in CTORS {

3464

            let c = ctor();

3465

            assert_eq!(c.a, ColorU::ALPHA_OPAQUE);

3466

            assert!(!c.has_alpha());

3467

3468

        // The one exception.

3469

        assert_eq!(ColorU::transparent().a, ColorU::ALPHA_TRANSPARENT);

3470

        assert!(ColorU::transparent().has_alpha());

3471

3472

3473

    #[test]

3474

    fn apple_and_bootstrap_palettes_are_opaque_and_distinct() {

3475

        type Ctor = fn() -> ColorU;

3476

        const APPLE: [Ctor; 26] = [

3477

            ColorU::apple_red,

3478

            ColorU::apple_red_dark,

3479

            ColorU::apple_orange,

3480

            ColorU::apple_orange_dark,

3481

            ColorU::apple_yellow,

3482

            ColorU::apple_yellow_dark,

3483

            ColorU::apple_green,

3484

            ColorU::apple_green_dark,

3485

            ColorU::apple_mint,

3486

            ColorU::apple_mint_dark,

3487

            ColorU::apple_teal,

3488

            ColorU::apple_teal_dark,

3489

            ColorU::apple_cyan,

3490

            ColorU::apple_cyan_dark,

3491

            ColorU::apple_blue,

3492

            ColorU::apple_blue_dark,

3493

            ColorU::apple_indigo,

3494

            ColorU::apple_indigo_dark,

3495

            ColorU::apple_purple,

3496

            ColorU::apple_purple_dark,

3497

            ColorU::apple_pink,

3498

            ColorU::apple_pink_dark,

3499

            ColorU::apple_brown,

3500

            ColorU::apple_brown_dark,

3501

            ColorU::apple_gray,

3502

            ColorU::apple_gray_dark,

3503

];

3504

        const BOOTSTRAP: [Ctor; 23] = [

3505

            ColorU::bootstrap_primary,

3506

            ColorU::bootstrap_primary_hover,

3507

            ColorU::bootstrap_primary_active,

3508

            ColorU::bootstrap_secondary,

3509

            ColorU::bootstrap_secondary_hover,

3510

            ColorU::bootstrap_secondary_active,

3511

            ColorU::bootstrap_success,

3512

            ColorU::bootstrap_success_hover,

3513

            ColorU::bootstrap_success_active,

3514

            ColorU::bootstrap_danger,

3515

            ColorU::bootstrap_danger_hover,

3516

            ColorU::bootstrap_danger_active,

3517

            ColorU::bootstrap_warning,

3518

            ColorU::bootstrap_warning_hover,

3519

            ColorU::bootstrap_warning_active,

3520

            ColorU::bootstrap_info,

3521

            ColorU::bootstrap_info_hover,

3522

            ColorU::bootstrap_info_active,

3523

            ColorU::bootstrap_light,

3524

            ColorU::bootstrap_light_hover,

3525

            ColorU::bootstrap_light_active,

3526

            ColorU::bootstrap_dark,

3527

            ColorU::bootstrap_dark_hover,

3528

];

3529

        for ctor in APPLE.iter().chain(BOOTSTRAP.iter()) {

3530

            assert_eq!(ctor().a, 255);

3531

3532

        // Each light/dark pair must actually differ.

3533

        for pair in APPLE.chunks_exact(2) {

3534

            assert_ne!(

3535

                pair[0](),

3536

                pair[1](),

3537

                "an apple light/dark pair is identical"

3538

);

3539

3540

        // bootstrap_link duplicates bootstrap_primary by design; check the hover shifts.

3541

        assert_eq!(ColorU::bootstrap_link(), ColorU::bootstrap_primary());

3542

        assert_ne!(ColorU::bootstrap_link_hover(), ColorU::bootstrap_link());

3543

        assert_ne!(ColorU::bootstrap_dark_active(), ColorU::bootstrap_dark());

3544

3545

3546

    // =====================================================================

3547

    // parser: parse_css_color — malformed / huge / boundary / unicode

3548

    // =====================================================================

3549

3550

    #[cfg(feature = "parser")]

3551

    #[test]

3552

    fn parse_css_color_valid_minimal_positive_controls() {

3553

        assert_eq!(parse_css_color("red").unwrap(), ColorU::RED);

3554

        assert_eq!(parse_css_color("#f00").unwrap(), ColorU::RED);

3555

        assert_eq!(parse_css_color("#ff0000").unwrap(), ColorU::RED);

3556

        assert_eq!(parse_css_color("rgb(255,0,0)").unwrap(), ColorU::RED);

3557

        assert_eq!(parse_css_color("hsl(0,100%,50%)").unwrap(), ColorU::RED);

3558

3559

3560

    #[cfg(feature = "parser")]

3561

    #[test]

3562

    fn parse_css_color_empty_and_whitespace_only_are_errors() {

3563

        assert!(parse_css_color("").is_err());

3564

        assert!(parse_css_color("   ").is_err());

3565

        assert!(parse_css_color("\t\n\r ").is_err());

3566

        assert!(parse_css_color("#").is_err());

3567

        assert_eq!(parse_css_color(""), Err(CssColorParseError::EmptyInput));

3568

        assert_eq!(

3569

            parse_css_color("  \t "),

3570

            Err(CssColorParseError::EmptyInput)

3571

);

3572

3573

3574

    #[cfg(feature = "parser")]

3575

    #[test]

3576

    fn parse_css_color_garbage_is_rejected_without_panicking() {

3577

        for garbage in [

3578

            "!@#$%^&*()",

3579

            "\0\0\0",

3580

            "rgb",

3581

            "rgb(",

3582

            "rgb)",

3583

            ")(",

3584

            "()",

3585

            "#-1",

3586

            "#+1",

3587

            "notacolor",

3588

            "0",

3589

            "-0",

3590

            "1e10",

3591

            "NaN",

3592

            "inf",

3593

            "-inf",

3594

            ";",

3595

            ",,,",

3596

            "\\",

3597

            "rgb(,,)",

3598

            "hsl(,,)",

3599

            "rgba(,,,)",

3600

            "#\u{0}\u{0}\u{0}",

3601

] {

3602

            assert!(

3603

                parse_css_color(garbage).is_err(),

3604

                "{garbage:?} was unexpectedly accepted"

3605

);

3606

3607

3608

3609

    #[cfg(feature = "parser")]

3610

    #[test]

3611

    fn parse_css_color_extremely_long_input_does_not_hang_or_panic() {

3612

        // Hex path: rejected on the length check alone.

3613

        let long_hex = format!("#{}", "f".repeat(1_000_000));

3614

        assert!(parse_css_color(&long_hex).is_err());

3615

        // Named-color path: lowercases 100k bytes, then fails the match.

3616

        let long_name = "a".repeat(100_000);

3617

        assert!(parse_css_color(&long_name).is_err());

3618

        // Function path with a huge component list.

3619

        let long_rgb = format!("rgb({})", "1,".repeat(50_000));

3620

        assert!(parse_css_color(&long_rgb).is_err());

3621

3622

3623

    #[cfg(feature = "parser")]

3624

    #[test]

3625

    fn parse_css_color_deeply_nested_input_does_not_stack_overflow() {

3626

        // The parser is iterative, not recursive — these must simply be errors.

3627

        let nested_parens = "(".repeat(10_000);

3628

        assert!(parse_css_color(&nested_parens).is_err());

3629

        let unclosed = "rgb(".repeat(10_000);

3630

        assert!(parse_css_color(&unclosed).is_err());

3631

        let balanced = format!("{}{}", "rgb(".repeat(5_000), ")".repeat(5_000));

3632

        assert!(parse_css_color(&balanced).is_err());

3633

3634

3635

    #[cfg(feature = "parser")]

3636

    #[test]

3637

    fn parse_css_color_unicode_input_does_not_panic() {

3638

        // The 3/4-byte hex branches read raw bytes, so a multi-byte char must

3639

        // fail cleanly rather than slice through a char boundary.

3640

        for input in [

3641

            "\u{1F600}",           // emoji

3642

            "#\u{1F600}",          // 4 bytes after '#' -> hits the len==4 branch

3643

            "#\u{e9}1",            // 3 bytes after '#' -> hits the len==3 branch

3644

            "#\u{e9}\u{e9}\u{e9}", // 6 bytes -> hits the from_str_radix branch

3645

            "r\u{e9}d",

3646

            "\u{0301}\u{0301}", // bare combining marks

3647

            "\u{4e2d}\u{6587}", // CJK

3648

            "rgb(\u{1F600},0,0)",

3649

            "rgba(0,0,0,\u{1F600})",

3650

            "hsl(\u{1F600},100%,50%)",

3651

] {

3652

            assert!(

3653

                parse_css_color(input).is_err(),

3654

                "{input:?} was unexpectedly accepted"

3655

);

3656

3657

3658

3659

    #[cfg(feature = "parser")]

3660

    #[test]

3661

    fn parse_css_color_boundary_numbers() {

3662

        // rgb components are u8: 0 and 255 in, 256 and -1 out.

3663

        assert_eq!(parse_css_color("rgb(0,0,0)").unwrap(), ColorU::BLACK);

3664

        assert_eq!(parse_css_color("rgb(255,255,255)").unwrap(), ColorU::WHITE);

3665

        assert!(parse_css_color("rgb(256,0,0)").is_err());

3666

        assert!(parse_css_color("rgb(-1,0,0)").is_err());

3667

        assert!(parse_css_color("rgb(9223372036854775807,0,0)").is_err());

3668

        assert!(parse_css_color("rgb(340282350000000000000000000000000000000,0,0)").is_err());

3669

        // Alpha is a float clamped to 0.0..=1.0 (inclusive), out-of-range rejected.

3670

        assert_eq!(parse_css_color("rgba(0,0,0,0)").unwrap().a, 0);

3671

        assert_eq!(parse_css_color("rgba(0,0,0,1)").unwrap().a, 255);

3672

        assert_eq!(parse_css_color("rgba(0,0,0,1.0)").unwrap().a, 255);

3673

        assert_eq!(parse_css_color("rgba(0,0,0,-0)").unwrap().a, 0);

3674

        assert!(parse_css_color("rgba(0,0,0,1.0001)").is_err());

3675

        assert!(parse_css_color("rgba(0,0,0,-0.0001)").is_err());

3676

        assert!(parse_css_color("rgba(0,0,0,2)").is_err());

3677

        // NaN / inf are valid f32 literals to FromStr, but must fail the range check.

3678

        assert!(parse_css_color("rgba(0,0,0,NaN)").is_err());

3679

        assert!(parse_css_color("rgba(0,0,0,nan)").is_err());

3680

        assert!(parse_css_color("rgba(0,0,0,inf)").is_err());

3681

        assert!(parse_css_color("rgba(0,0,0,-inf)").is_err());

3682

        assert!(parse_css_color("rgba(0,0,0,infinity)").is_err());

3683

        // Subnormals round down to a fully transparent alpha rather than panicking.

3684

        assert_eq!(parse_css_color("rgba(0,0,0,1e-45)").unwrap().a, 0);

3685

3686

3687

    #[cfg(feature = "parser")]

3688

    #[test]

3689

    fn parse_css_color_alpha_rounds_to_nearest() {

3690

        // `(a * 255.0).round()` — half rounds away from zero.

3691

        assert_eq!(parse_css_color("rgba(0,0,0,0.5)").unwrap().a, 128);

3692

        assert_eq!(parse_css_color("rgba(0,0,0,0.0)").unwrap().a, 0);

3693

        assert_eq!(parse_css_color("rgba(0,0,0,0.999)").unwrap().a, 255);

3694

3695

3696

    #[cfg(feature = "parser")]

3697

    #[test]

3698

    fn parse_css_color_arity_errors() {

3699

        assert!(parse_css_color("rgb(255,0)").is_err()); // missing blue

3700

        assert!(parse_css_color("rgb(255)").is_err()); // missing green

3701

        assert!(parse_css_color("rgb()").is_err()); // missing everything

3702

        assert!(parse_css_color("rgb(0,0,0,0)").is_err()); // extra arg to rgb()

3703

        assert!(parse_css_color("rgba(0,0,0)").is_err()); // missing alpha

3704

        assert!(parse_css_color("rgba(0,0,0,1,1)").is_err()); // extra arg to rgba()

3705

        assert!(parse_css_color("hsl(0,100%)").is_err()); // missing lightness

3706

        assert!(parse_css_color("hsla(0,100%,50%)").is_err()); // missing alpha

3707

                                                               // This implementation requires

3708

                                                               // commas; space-separated CSS4

3709

                                                               // syntax is not supported.

3710

        assert!(parse_css_color("rgb(255 0 0)").is_err());

3711

3712

3713

    #[cfg(feature = "parser")]

3714

    #[test]

3715

    fn parse_css_color_leading_and_trailing_whitespace_is_trimmed() {

3716

        assert_eq!(parse_css_color("  red  ").unwrap(), ColorU::RED);

3717

        assert_eq!(parse_css_color("\t#f00\n").unwrap(), ColorU::RED);

3718

        assert_eq!(

3719

            parse_css_color("  rgb( 255 , 0 , 0 )  ").unwrap(),

3720

            ColorU::RED

3721

);

3722

        // Trailing junk after a bare keyword IS rejected.

3723

        assert!(parse_css_color("red;garbage").is_err());

3724

        assert!(parse_css_color("red red").is_err());

3725

        assert!(parse_css_color("#f00;").is_err());

3726

3727

3728

    #[cfg(feature = "parser")]

3729

    #[test]

3730

    fn parse_css_color_accepts_trailing_junk_after_a_function_call() {

3731

        // KNOWN DEVIATION (pinned, not endorsed): parse_parentheses slices between

3732

        // the FIRST '(' and the LAST ')', so anything after the closing paren is

3733

        // silently dropped instead of being rejected as an error. See report.

3734

        assert_eq!(

3735

            parse_css_color("rgb(1,2,3)garbage").unwrap(),

3736

            ColorU::rgb(1, 2, 3)

3737

);

3738

        assert_eq!(

3739

            parse_css_color("rgb(1,2,3);").unwrap(),

3740

            ColorU::rgb(1, 2, 3)

3741

);

3742

3743

3744

    #[cfg(feature = "parser")]

3745

    #[test]

3746

    fn parse_css_color_hex_is_case_insensitive_and_length_checked() {

3747

        assert_eq!(

3748

            parse_css_color("#ABCDEF").unwrap(),

3749

            parse_css_color("#abcdef").unwrap()

3750

);

3751

        assert_eq!(parse_css_color("#FFF").unwrap(), ColorU::WHITE);

3752

        // 3/4-digit shorthand expands by *17 (f -> 0xff).

3753

        assert_eq!(

3754

            parse_css_color("#f00f").unwrap(),

3755

            ColorU::rgba(255, 0, 0, 255)

3756

);

3757

        assert_eq!(

3758

            parse_css_color("#0008").unwrap(),

3759

            ColorU::rgba(0, 0, 0, 136)

3760

);

3761

        // Only lengths 3, 4, 6 and 8 are legal.

3762

        for bad_len in ["#", "#f", "#ff", "#fffff", "#fffffff", "#fffffffff"] {

3763

            assert!(parse_css_color(bad_len).is_err(), "{bad_len} accepted");

3764

3765

        // Non-hex digits.

3766

        assert!(parse_css_color("#ggg").is_err());

3767

        assert!(parse_css_color("#gggggg").is_err());

3768

        assert!(parse_css_color("#-12345").is_err());

3769

        assert!(parse_css_color("#+f0000").is_err());

3770

        assert!(parse_css_color("#ff ff").is_err());

3771

3772

3773

    #[cfg(feature = "parser")]

3774

    #[test]

3775

    fn parse_css_color_builtin_names_are_case_insensitive() {

3776

        assert_eq!(parse_css_color("RED").unwrap(), ColorU::RED);

3777

        assert_eq!(parse_css_color("ReD").unwrap(), ColorU::RED);

3778

        assert_eq!(parse_css_color("TRANSPARENT").unwrap(), ColorU::TRANSPARENT);

3779

        assert_eq!(parse_css_color("transparent").unwrap().a, 0);

3780

        // Near-miss names are rejected, not fuzzy-matched.

3781

        for near_miss in ["redd", "re", "r ed", "red1", "gray2", "greyish", "blackk"] {

3782

            assert!(parse_css_color(near_miss).is_err(), "{near_miss} accepted");

3783

3784

        // ...but surrounding whitespace really is just trimmed.

3785

        assert_eq!(parse_css_color(" grey ").unwrap(), ColorU::GRAY);

3786

3787

3788

    #[cfg(feature = "parser")]

3789

    #[test]

3790

    fn parse_css_color_hsl_boundaries_and_hue_wraparound() {

3791

        assert_eq!(parse_css_color("hsl(0,100%,50%)").unwrap(), ColorU::RED);

3792

        assert_eq!(parse_css_color("hsl(120,100%,50%)").unwrap(), ColorU::GREEN);

3793

        assert_eq!(parse_css_color("hsl(240,100%,50%)").unwrap(), ColorU::BLUE);

3794

        // A full extra turn lands back on red.

3795

        assert_eq!(parse_css_color("hsl(720,100%,50%)").unwrap(), ColorU::RED);

3796

        // Achromatic ends.

3797

        assert_eq!(parse_css_color("hsl(0,0%,0%)").unwrap(), ColorU::BLACK);

3798

        assert_eq!(parse_css_color("hsl(0,0%,100%)").unwrap(), ColorU::WHITE);

3799

        // Huge but finite hues must not panic.

3800

        for hue in ["1000000", "99999999", "-360"] {

3801

            let s = format!("hsl({hue},100%,50%)");

3802

            let _ = parse_css_color(&s).map(|c| assert_eq!(c.a, 255));

3803

3804

3805

3806

    #[cfg(feature = "parser")]

3807

    #[test]

3808

    fn parse_css_color_unitless_hsl_components_are_scaled_wrong() {

3809

        // KNOWN DEVIATION (pinned, not endorsed): `parse_percentage_value` turns a

3810

        // unitless value into `value * 100` percent, and `percent_from_str` then

3811

        // re-normalizes it, so a unitless component is a 0..1 FRACTION rather than

3812

        // the CSS Color 4 "number of percent". `hsl(0 100 50)` — plain red in every

3813

        // browser — comes out CYAN here. Pinned so a fix shows up as a diff.

3814

        assert_eq!(

3815

            parse_css_color("hsl(0,100,50)").unwrap(),

3816

            ColorU::rgb(0, 255, 255)

3817

);

3818

        // The fraction spelling is what currently means "100% / 50%".

3819

        assert_eq!(parse_css_color("hsl(0,1,0.5)").unwrap(), ColorU::RED);

3820

        // The mixed spelling that the existing suite smoke-tests happens to land on

3821

        // red by coincidence (the out-of-range saturation clips back into gamut).

3822

        assert_eq!(parse_css_color("hsl(0,100,50%)").unwrap(), ColorU::RED);

3823

3824

3825

    // =====================================================================

3826

    // parser: private helpers

3827

    // =====================================================================

3828

3829

    #[cfg(feature = "parser")]

3830

    #[test]

3831

    fn parse_color_no_hash_only_accepts_3_4_6_and_8_bytes() {

3832

        assert_eq!(parse_color_no_hash("fff").unwrap(), ColorU::WHITE);

3833

        assert_eq!(parse_color_no_hash("000f").unwrap(), ColorU::BLACK);

3834

        assert_eq!(parse_color_no_hash("ff0000").unwrap(), ColorU::RED);

3835

        assert_eq!(

3836

            parse_color_no_hash("ff000080").unwrap(),

3837

            ColorU::rgba(255, 0, 0, 128)

3838

);

3839

        for bad in ["", "f", "ff", "fffff", "fffffff", "fffffffff", "   ", "zzz"] {

3840

            assert!(parse_color_no_hash(bad).is_err(), "{bad:?} accepted");

3841

3842

        // `input.len()` is a BYTE length, so a 3-byte multi-byte string reaches

3843

        // the byte-reading branch and must error, not slice through a char.

3844

        assert!(parse_color_no_hash("\u{e9}1").is_err());

3845

        assert!(parse_color_no_hash("\u{1F600}").is_err());

3846

3847

3848

    #[cfg(feature = "parser")]

3849

    #[test]

3850

    fn parse_color_rgb_alpha_flag_controls_arity() {

3851

        assert_eq!(

3852

            parse_color_rgb("1,2,3", false).unwrap(),

3853

            ColorU::rgb(1, 2, 3)

3854

);

3855

        assert_eq!(

3856

            parse_color_rgb("1,2,3,1", true).unwrap(),

3857

            ColorU::rgba(1, 2, 3, 255)

3858

);

3859

        // parse_alpha=true but no alpha given.

3860

        assert!(parse_color_rgb("1,2,3", true).is_err());

3861

        // parse_alpha=false but an alpha given.

3862

        assert!(parse_color_rgb("1,2,3,1", false).is_err());

3863

        // Empty / whitespace components.

3864

        assert!(parse_color_rgb("", false).is_err());

3865

        assert!(parse_color_rgb("   ", false).is_err());

3866

        assert!(parse_color_rgb(",,", false).is_err());

3867

        assert!(parse_color_rgb("1,,3", false).is_err());

3868

3869

3870

    #[cfg(feature = "parser")]

3871

    #[test]

3872

    fn parse_color_rgb_components_boundaries() {

3873

        let mut ok = ["0", "128", "255"].into_iter();

3874

        assert_eq!(

3875

            parse_color_rgb_components(&mut ok).unwrap(),

3876

            ColorU::rgb(0, 128, 255)

3877

);

3878

        // An empty iterator is a missing-component error, not a panic.

3879

        let mut empty = core::iter::empty::<&str>();

3880

        assert!(parse_color_rgb_components(&mut empty).is_err());

3881

        // Too few components.

3882

        let mut short = ["1", "2"].into_iter();

3883

        assert!(parse_color_rgb_components(&mut short).is_err());

3884

        // Overflow / underflow / garbage.

3885

        for bad in [

3886

            ["256", "0", "0"],

3887

            ["-1", "0", "0"],

3888

            ["0", "0", "1e3"],

3889

            ["0.5", "0", "0"],

3890

            ["abc", "0", "0"],

3891

            ["", "0", "0"],

3892

            ["+0", "0", "999999999999999999999"],

3893

] {

3894

            let mut it = bad.into_iter();

3895

            assert!(

3896

                parse_color_rgb_components(&mut it).is_err(),

3897

                "{bad:?} accepted"

3898

);

3899

3900

        // Extra components past the third are simply not consumed here.

3901

        let mut extra = ["1", "2", "3", "4", "5"].into_iter();

3902

        assert_eq!(

3903

            parse_color_rgb_components(&mut extra).unwrap(),

3904

            ColorU::rgb(1, 2, 3)

3905

);

3906

        assert_eq!(extra.next(), Some("4"));

3907

3908

3909

    #[cfg(feature = "parser")]

3910

    #[test]

3911

    fn parse_color_hsl_components_boundaries() {

3912

        let mut red = ["0", "100%", "50%"].into_iter();

3913

        assert_eq!(parse_color_hsl_components(&mut red).unwrap(), ColorU::RED);

3914

        // KNOWN DEVIATION (pinned, not endorsed): a unitless component is read as

3915

        // a 0.0..=1.0 FRACTION, not as a number of percent, so CSS Color 4's

3916

        // `hsl(0 100 50)` saturation/lightness are scaled 100x too far. Only the

3917

        // fraction spelling currently round-trips to red. See report.

3918

        let mut fractions = ["0", "1", "0.5"].into_iter();

3919

        assert_eq!(

3920

            parse_color_hsl_components(&mut fractions).unwrap(),

3921

            ColorU::RED

3922

);

3923

        let mut unitless = ["0", "100", "50"].into_iter();

3924

        assert_eq!(

3925

            parse_color_hsl_components(&mut unitless).unwrap(),

3926

            ColorU::rgb(0, 255, 255),

3927

            "unitless hsl(0 100 50) should be red, not cyan"

3928

);

3929

        // Missing components error rather than panic.

3930

        let mut empty = core::iter::empty::<&str>();

3931

        assert!(parse_color_hsl_components(&mut empty).is_err());

3932

        let mut short = ["0", "100%"].into_iter();

3933

        assert!(parse_color_hsl_components(&mut short).is_err());

3934

        for bad in [

3935

            ["", "100%", "50%"],

3936

            ["notanangle", "100%", "50%"],

3937

            ["to left", "100%", "50%"], // Direction::FromTo is unsupported for hue

3938

            ["0", "", "50%"],

3939

            ["0", "100%", ""],

3940

] {

3941

            let mut it = bad.into_iter();

3942

            assert!(

3943

                parse_color_hsl_components(&mut it).is_err(),

3944

                "{bad:?} accepted"

3945

);

3946

3947

3948

3949

    #[cfg(feature = "parser")]

3950

    #[test]

3951

    fn parse_alpha_component_range_and_rounding() {

3952

        let cases: [(&str, u8); 5] = [("0", 0), ("0.0", 0), ("0.5", 128), ("1", 255), ("1.0", 255)];

3953

        for (input, expected) in cases {

3954

            let mut it = [input].into_iter();

3955

            assert_eq!(

3956

                parse_alpha_component(&mut it).unwrap(),

3957

                expected,

3958

                "alpha {input}"

3959

);

3960

3961

        // Out of range / unparseable / NaN / inf all produce Err, never a panic.

3962

        for bad in [

3963

            "", " ", "-0.0001", "1.0001", "2", "-1", "NaN", "inf", "-inf", "abc", "0,5", "50%",

3964

] {

3965

            let mut it = [bad].into_iter();

3966

            assert!(parse_alpha_component(&mut it).is_err(), "{bad:?} accepted");

3967

3968

        // Missing entirely.

3969

        let mut empty = core::iter::empty::<&str>();

3970

        assert!(parse_alpha_component(&mut empty).is_err());

3971

3972

3973

    #[cfg(feature = "parser")]

3974

    #[test]

3975

    fn parse_color_builtin_rejects_junk_without_panicking() {

3976

        assert_eq!(parse_color_builtin("red").unwrap(), ColorU::RED);

3977

        assert_eq!(

3978

            parse_color_builtin("REBECCAPURPLE").unwrap(),

3979

            ColorU::rgb(102, 51, 153)

3980

);

3981

        assert_eq!(

3982

            parse_color_builtin("transparent").unwrap(),

3983

            ColorU::TRANSPARENT

3984

);

3985

        // Not trimmed at this level — the caller is responsible for that.

3986

        assert!(parse_color_builtin(" red").is_err());

3987

        assert!(parse_color_builtin("").is_err());

3988

        // to_lowercase() on exotic input must not panic (dotted capital I expands).

3989

        assert!(parse_color_builtin("\u{130}").is_err());

3990

        assert!(parse_color_builtin("\u{1F600}").is_err());

3991

        assert!(parse_color_builtin(&"z".repeat(100_000)).is_err());

3992

3993

3994

    // =====================================================================

3995

    // parser: parse_color_or_system

3996

    // =====================================================================

3997

3998

    #[cfg(feature = "parser")]

3999

    #[test]

4000

    fn parse_color_or_system_rejects_bad_system_names() {

4001

        for bad in [

4002

            "system:",

4003

            "system:invalid",

4004

            "system: ",

4005

            "system::text",

4006

            "system:text-",

4007

            "system:TEXT", // the variant table is case-SENSITIVE

4008

            "SYSTEM:text", // the prefix is case-SENSITIVE

4009

            "system:text;junk",

4010

            "system:\u{1F600}",

4011

] {

4012

            assert!(parse_color_or_system(bad).is_err(), "{bad:?} accepted");

4013

4014

        // Empty / whitespace.

4015

        assert!(parse_color_or_system("").is_err());

4016

        assert!(parse_color_or_system("   ").is_err());

4017

4018

4019

    #[cfg(feature = "parser")]

4020

    #[test]

4021

    fn parse_color_or_system_trims_and_falls_through_to_colors() {

4022

        assert_eq!(

4023

            parse_color_or_system("  system:accent  ").unwrap(),

4024

            ColorOrSystem::System(SystemColorRef::Accent)

4025

);

4026

        // The name after the prefix is trimmed too.

4027

        assert_eq!(

4028

            parse_color_or_system("system: accent ").unwrap(),

4029

            ColorOrSystem::System(SystemColorRef::Accent)

4030

);

4031

        // Non-system input is delegated to parse_css_color.

4032

        assert_eq!(

4033

            parse_color_or_system("  #f00 ").unwrap(),

4034

            ColorOrSystem::Color(ColorU::RED)

4035

);

4036

        assert_eq!(

4037

            parse_color_or_system("rgba(0,0,0,0)").unwrap(),

4038

            ColorOrSystem::Color(ColorU::TRANSPARENT)

4039

);

4040

        assert!(parse_color_or_system("definitely-not-a-color").is_err());

4041

4042

4043

    #[cfg(feature = "parser")]

4044

    #[test]

4045

    fn parse_color_or_system_long_and_nested_input_does_not_hang() {

4046

        let long = format!("system:{}", "a".repeat(100_000));

4047

        assert!(parse_color_or_system(&long).is_err());

4048

        let nested = "rgb(".repeat(10_000);

4049

        assert!(parse_color_or_system(&nested).is_err());

4050

4051

4052

    // =====================================================================

4053

    // error types: to_contained / to_shared round-trip

4054

    // =====================================================================

4055

4056

    #[cfg(feature = "parser")]

4057

    #[test]

4058

    fn css_color_parse_error_round_trips_through_owned() {

4059

        // One representative input per reachable error variant.

4060

        let errors = [

4061

            parse_css_color("notacolor").unwrap_err(), // InvalidColor

4062

            parse_css_color("foo(1,2)").unwrap_err(),  // InvalidFunctionName

4063

            parse_css_color("#zzz").unwrap_err(),      // InvalidColorComponent

4064

            parse_css_color("rgb(300,0,0)").unwrap_err(), // IntValueParseErr

4065

            parse_css_color("rgba(0,0,0,x)").unwrap_err(), // FloatValueParseErr

4066

            parse_css_color("rgba(0,0,0,2)").unwrap_err(), // FloatValueOutOfRange

4067

            parse_css_color("rgb(1,2)").unwrap_err(),  // MissingColorComponent

4068

            parse_css_color("rgb(1,2,3,4)").unwrap_err(), // ExtraArguments

4069

            parse_css_color("rgb(1,2,3").unwrap_err(), // UnclosedColor

4070

            parse_css_color("").unwrap_err(),          // EmptyInput

4071

            parse_css_color("hsl(x,1%,1%)").unwrap_err(), // DirectionParseError

4072

            parse_css_color("hsl(0,x%,1%)").unwrap_err(), // InvalidPercentage

4073

];

4074

        for e in &errors {

4075

            let owned = e.to_contained();

4076

            let shared = owned.to_shared();

4077

            // Borrowed -> owned -> borrowed -> owned must be a fixed point.

4078

            assert_eq!(

4079

                shared.to_contained(),

4080

                owned,

4081

                "error did not round-trip: {e}"

4082

);

4083

            // Debug/Display must both produce something non-empty.

4084

            assert!(!format!("{e}").is_empty());

4085

            assert!(!format!("{e:?}").is_empty());

4086

            assert!(!format!("{owned:?}").is_empty());

4087

4088

4089

4090

    #[cfg(feature = "parser")]

4091

    #[test]

4092

    fn css_color_parse_error_carries_the_offending_input() {

4093

        assert_eq!(

4094

            parse_css_color("notacolor"),

4095

            Err(CssColorParseError::InvalidColor("notacolor"))

4096

);

4097

        assert_eq!(

4098

            parse_css_color("rgb(1,2,3,4)"),

4099

            Err(CssColorParseError::ExtraArguments("4"))

4100

);

4101

        assert_eq!(

4102

            parse_css_color("rgb(1,2)"),

4103

            Err(CssColorParseError::MissingColorComponent(

4104

                CssColorComponent::Blue

4105

))

4106

);

4107

        assert_eq!(

4108

            parse_css_color("rgba(1,2,3)"),

4109

            Err(CssColorParseError::MissingColorComponent(

4110

                CssColorComponent::Alpha

4111

))

4112

);

4113

        assert_eq!(

4114

            parse_css_color("rgba(0,0,0,2)"),

4115

            Err(CssColorParseError::FloatValueOutOfRange(2.0))

4116

);

4117

        // The byte, not the char, is reported for a bad hex digit.

4118

        assert_eq!(

4119

            parse_css_color("#zzz"),

4120

            Err(CssColorParseError::InvalidColorComponent(b'z'))

4121

);

4122

4123