refactor(class-variance): fixing mago errors

Author: iamdadmin

packages/class-variance/src/ClassNames.php

@@ -29,7 +29,7 @@ private function __construct(
      * Passing $slot = '' is the passthrough context (e.g. extra $props['class'])
      * and always emits the classes regardless of slot.
      *
-     * @param string|array<array-key, mixed>|bool $input
+     * @param string|list<string|array<string, mixed>|bool>|array<string, string|array<string, mixed>|bool>|bool $input
      */
     public static function of(string|array|bool $input, string $slot = ''): self
     {

packages/class-variance/src/Classmaps/Classmap.php

@@ -60,10 +60,6 @@ public function findGroup(string $class): ?string
                     continue;
                 }
 
-                if (! is_array($matcher)) {
-                    continue;
-                }
-
                 if (array_is_list($matcher)) {
                     // ['prefix'] — wildcard: matches prefix itself or prefix-{anything}
                     $prefix = $matcher[0];
@@ -73,7 +69,8 @@ public function findGroup(string $class): ?string
                     }
                 } else {
                     // ['prefix' => ['suffix1', 'suffix2']] — constrained suffix list
-                    $prefix = array_key_first($matcher);
+                    $prefix = (string) array_key_first($matcher);
+                    /** @var list<string> $suffixes */
                     $suffixes = $matcher[$prefix];
 
                     foreach ($suffixes as $suffix) {
@@ -102,7 +99,9 @@ public function extend(self $additions): self
         $groups = $this->classGroups;
 
         foreach ($additions->classGroups as $groupId => $matchers) {
-            $groups[$groupId] = array_merge($groups[$groupId] ?? [], $matchers);
+            /** @var list<string|array<string, list<string>>|array{0: string}> $merged */
+            $merged = array_merge($groups[$groupId] ?? [], $matchers);
+            $groups[$groupId] = $merged;
         }
 
         $conflicts = $this->conflictingClassGroups;
@@ -123,9 +122,11 @@ public function extend(self $additions): self
      */
     public function override(self $replacements): self
     {
-        return new self(
-            array_replace($this->classGroups, $replacements->classGroups),
-            array_replace($this->conflictingClassGroups, $replacements->conflictingClassGroups),
-        );
+        /** @var array<string, list<string|array<string, list<string>>|array{0: string}>> $newGroups */
+        $newGroups = array_replace($this->classGroups, $replacements->classGroups);
+        /** @var array<string, list<string>> $newConflicts */
+        $newConflicts = array_replace($this->conflictingClassGroups, $replacements->conflictingClassGroups);
+
+        return new self($newGroups, $newConflicts);
     }
 }

packages/class-variance/src/Config/TailwindClassVarianceConfig.php

@@ -32,12 +32,14 @@ public function __construct(
         get {
             $groups = TailwindClassmap::default();
 
-            if ($this->extend !== null) {
-                $groups = $groups->extend($this->extend);
+            $extend = $this->extend;
+            if ($extend instanceof Classmap) {
+                $groups = $groups->extend($extend);
             }
 
-            if ($this->override !== null) {
-                $groups = $groups->override($this->override);
+            $override = $this->override;
+            if ($override instanceof Classmap) {
+                $groups = $groups->override($override);
             }
 
             return new GroupClassMerger($groups, $this->prefix, $this->separator);

packages/class-variance/src/GroupClassMerger.php

@@ -74,6 +74,8 @@ public function merge(string ...$classes): string
      *
      * Example: 'dark:hover:bg-red-500' → ['dark:hover', 'bg-red-500']
      * Example: 'p-[color:red]'         → ['', 'p-[color:red]']
+     *
+     * @return array{0: string, 1: string}
      */
     private function extractModifiers(string $class): array
     {

packages/class-variance/src/ResolvesVariants.php

@@ -9,17 +9,24 @@
 /**
  * Core variant resolution engine, shared by all ClassVariance implementations.
  *
- * The class using this trait must declare the following public readonly properties:
+ * The class using this trait must declare the following public readable properties:
  *   - array|string $base
  *   - ClassMerger  $merger
  *   - array        $variants
  *   - array        $compoundVariants
  *   - array        $defaultVariants
  *
+ * @property-read array|string $base
+ * @property-read ClassMerger $merger
+ * @property-read array $variants
+ * @property-read array $compoundVariants
+ * @property-read array $defaultVariants
+ *
  * @internal
  */
 trait ResolvesVariants
 {
+    /** @param array<string, string|bool> $props */
     public function __invoke(array $props = [], string $slot = ''): string
     {
         $props = $this->applyDefaultVariants($props);
@@ -33,10 +40,16 @@ public function __invoke(array $props = [], string $slot = ''): string
         return $this->merger->merge(...$classes->toArray());
     }
 
-    /** @param array<string, string|bool> $props */
+    /**
+     * @param array<string, string|bool> $props
+     * @return array<string, string|bool>
+     */
     private function applyDefaultVariants(array $props): array
     {
-        foreach ($this->defaultVariants as $key => $value) {
+        /** @var array<string, string|bool> $defaults */
+        $defaults = $this->defaultVariants;
+
+        foreach ($defaults as $key => $value) {
             $props[$key] ??= $value;
         }
 
@@ -76,6 +89,7 @@ private function resolveSlot(string $slot): string
      */
     private function resolvePassthrough(array $props, string $slot): ClassNames
     {
+        /** @var string|array<array-key, mixed>|bool $value */
         $value = $props['class'] ?? $props['className'] ?? '';
 
         if (is_bool($value) || $value === '') {
@@ -98,8 +112,12 @@ private function resolveVariants(array $props, string $slot): ClassNames
     {
         $classes = ClassNames::empty();
 
+        /** @var array<string, array<string, string|array<string, mixed>>> $variants */
+        $variants = $this->variants;
+
         foreach ($props as $key => $value) {
-            $entry = $this->variants[$key][$value] ?? null;
+            $lookupKey = is_bool($value) ? ($value ? 'true' : 'false') : $value;
+            $entry = $variants[$key][$lookupKey] ?? null;
 
             if ($entry === null) {
                 continue;
@@ -118,11 +136,15 @@ private function resolveCompoundVariants(array $props, string $slot): ClassNames
     {
         $classes = ClassNames::empty();
 
-        foreach ($this->compoundVariants as $compound) {
+        /** @var array<int, array<string, mixed>> $compoundVariants */
+        $compoundVariants = $this->compoundVariants;
+
+        foreach ($compoundVariants as $compound) {
             if (! $this->compoundMatches($props, $compound)) {
                 continue;
             }
 
+            /** @var string|array<string, mixed>|bool $classValue */
             $classValue = $compound['class'] ?? $compound['className'] ?? '';
             $classes = $classes->concat(ClassNames::of($classValue, $slot));
         }
@@ -137,10 +159,12 @@ private function resolveCompoundVariants(array $props, string $slot): ClassNames
     private function compoundMatches(array $props, array $compound): bool
     {
         foreach ($compound as $key => $value) {
-            if ($key === 'class' || $key === 'className') {
+            if ($key === 'class') {
+                continue;
+            }
+            if ($key === 'className') {
                 continue;
             }
-
             if (is_array($value)) {
                 if (! isset($props[$key]) || ! in_array($props[$key], $value, strict: true)) {
                     return false;

packages/class-variance/src/SeparatorClassMerger.php

@@ -49,7 +49,7 @@ public function merge(string ...$classes): string
     private function resolveGroup(string $class): string
     {
         // Explicit group map takes priority over separator heuristic.
-        if ($this->classGroups !== null) {
+        if ($this->classGroups instanceof Classmap) {
             $group = $this->classGroups->findGroup($class);
 
             if ($group !== null) {