inkbridge 0.1.0-beta.2 → 0.1.0-beta.21

package/src/{state-analyzer.ts → tailwind/state-analyzer.ts}

@@ -16,6 +16,42 @@ export type StateInfo = {
 
 const RESPONSIVE_VARIANTS = new Set(['sm', 'md', 'lg', 'xl', '2xl']);
 
+function dedupeClasses(classes: string[]): string[] {
+  const out: string[] = [];
+  const seen: Record<string, true> = {};
+  for (let i = 0; i < classes.length; i++) {
+    const token = String(classes[i] || '').trim();
+    if (!token || seen[token]) continue;
+    seen[token] = true;
+    out.push(token);
+  }
+  return out;
+}
+
+function classifyStateVariant(variant: string): string | null {
+  const normalized = String(variant || '').trim().toLowerCase();
+  if (!normalized) return null;
+
+  if (normalized === 'hover') return 'hover';
+  if (normalized === 'focus-visible') return 'focus-visible';
+  if (normalized === 'focus' || normalized === 'focus-within') return 'focus';
+  if (normalized === 'active') return 'active';
+
+  if (normalized === 'disabled' || normalized === 'peer-disabled') return 'disabled';
+  if (normalized === 'checked') return 'checked';
+
+  if (normalized === 'aria-invalid') return 'error';
+  if (normalized === 'aria-checked') return 'checked';
+  if (normalized === 'aria-disabled') return 'disabled';
+
+  if (normalized.indexOf('[checked]') !== -1 || normalized.indexOf('state=checked') !== -1) return 'checked';
+  if (normalized.indexOf('[disabled]') !== -1) return 'disabled';
+  if (normalized.indexOf('state=open') !== -1) return 'open';
+  if (normalized.indexOf('invalid') !== -1) return 'error';
+
+  return null;
+}
+
 function extractStateVariant(variants: string[]): { state: string; variant: string } | null {
   const filtered: string[] = [];
   for (const v of variants) {
@@ -23,9 +59,36 @@ function extractStateVariant(variants: string[]): { state: string; variant: stri
     filtered.push(v);
   }
 
+  for (let i = 0; i < filtered.length; i++) {
+    const token = filtered[i];
+    const state = classifyStateVariant(token);
+    if (state) {
+      return { state: state, variant: token };
+    }
+  }
+
   const state = variantState(filtered);
   if (state) {
-    const match = filtered.find(v => v === state) || state;
+    let match = filtered.find(v => v === state) || null;
+    if (!match) {
+      if (state === 'checked') {
+        match = filtered.find(v => v.indexOf('checked') !== -1) || null;
+      } else if (state === 'disabled') {
+        match = filtered.find(v => v.indexOf('disabled') !== -1) || null;
+      } else if (state === 'open') {
+        match = filtered.find(v => v.indexOf('state=open') !== -1 || v.indexOf('open') !== -1) || null;
+      } else if (state === 'error') {
+        match = filtered.find(v => v.indexOf('invalid') !== -1 || v.indexOf('error') !== -1) || null;
+      } else if (state === 'focus' || state === 'focus-visible') {
+        match = filtered.find(v => v === 'focus-visible' || v === 'focus' || v === 'focus-within') || null;
+      }
+    }
+    if (!match && filtered.length > 0) {
+      match = filtered[filtered.length - 1];
+    }
+    if (!match) {
+      match = state;
+    }
     return { state: state, variant: match };
   }
 
@@ -110,14 +173,17 @@ export function analyzeStateEffects(classes: string[], colorGroup: Record<string
   return effects;
 }
 
-export function mergeStatesWithDefinition(extracted: StateInfo[], defined: any): StateInfo[] {
+export function mergeStatesWithDefinition(
+  extracted: StateInfo[],
+  defined: { states?: Record<string, { classes?: string[] }> } | null | undefined
+): StateInfo[] {
   if (!defined || !defined.states) return extracted;
   const map: Record<string, StateInfo> = {};
   for (const entry of extracted) {
     map[entry.name] = {
       name: entry.name,
       trigger: entry.trigger,
-      classes: entry.classes.slice(),
+      classes: dedupeClasses(entry.classes.slice()),
       effects: entry.effects,
     };
   }
@@ -130,12 +196,12 @@ export function mergeStatesWithDefinition(extracted: StateInfo[], defined: any):
       map[stateName] = {
         name: stateName,
         trigger: stateName + ':',
-        classes: defClasses.slice(),
+        classes: dedupeClasses(defClasses.slice()),
       };
       continue;
     }
     if (defClasses.length > 0) {
-      map[stateName].classes = map[stateName].classes.concat(defClasses);
+      map[stateName].classes = dedupeClasses(map[stateName].classes.concat(defClasses));
     }
   }