inkhouse 0.1.0-beta.0

package/src/state-analyzer.ts

@@ -0,0 +1,143 @@
+import { parseUtilityClass, variantState } from './utility-resolver';
+import { tailwindClassesToStyle } from './tailwind';
+
+export type StateEffect = {
+  property: 'background' | 'border' | 'text' | 'opacity' | 'underline';
+  value: string;
+  token?: string | null;
+};
+
+export type StateInfo = {
+  name: string;
+  trigger: string;
+  classes: string[];
+  effects?: StateEffect[];
+};
+
+const RESPONSIVE_VARIANTS = new Set(['sm', 'md', 'lg', 'xl', '2xl']);
+
+function extractStateVariant(variants: string[]): { state: string; variant: string } | null {
+  const filtered: string[] = [];
+  for (const v of variants) {
+    if (RESPONSIVE_VARIANTS.has(v)) continue;
+    filtered.push(v);
+  }
+
+  const state = variantState(filtered);
+  if (state) {
+    const match = filtered.find(v => v === state) || state;
+    return { state: state, variant: match };
+  }
+
+  for (const v of filtered) {
+    if (v.startsWith('group-') || v.startsWith('peer-')) {
+      return { state: v, variant: v };
+    }
+  }
+
+  return null;
+}
+
+function stripStateVariant(input: string, variant: string): string | null {
+  const parsed = parseUtilityClass(input);
+  const nextVariants: string[] = [];
+  for (const v of parsed.variants) {
+    if (v === variant) continue;
+    nextVariants.push(v);
+  }
+  if (!parsed.utility) return null;
+  let rebuilt = parsed.utility;
+  if (nextVariants.length > 0) {
+    rebuilt = nextVariants.join(':') + ':' + parsed.utility;
+  }
+  if (parsed.important) rebuilt = '!' + rebuilt;
+  return rebuilt;
+}
+
+export function extractStatesFromClasses(classes: string[]): StateInfo[] {
+  const stateMap: Record<string, StateInfo> = {};
+  const ensure = (name: string, trigger: string): StateInfo => {
+    if (!stateMap[name]) {
+      stateMap[name] = { name: name, trigger: trigger, classes: [] };
+    }
+    return stateMap[name];
+  };
+
+  ensure('default', '');
+
+  for (const cls of classes) {
+    const parsed = parseUtilityClass(cls);
+    const stateInfo = extractStateVariant(parsed.variants);
+    if (!stateInfo) {
+      stateMap['default'].classes.push(cls);
+      continue;
+    }
+    const stripped = stripStateVariant(cls, stateInfo.variant);
+    if (!stripped) continue;
+    const entry = ensure(stateInfo.state, stateInfo.variant + ':');
+    entry.classes.push(stripped);
+  }
+
+  return Object.keys(stateMap).map(key => stateMap[key]);
+}
+
+export function getStateClasses(classes: string[], state: string): string[] {
+  const extracted = extractStatesFromClasses(classes);
+  for (const entry of extracted) {
+    if (entry.name === state) return entry.classes.slice();
+  }
+  return [];
+}
+
+export function analyzeStateEffects(classes: string[], colorGroup: Record<string, string>): StateEffect[] {
+  const effects: StateEffect[] = [];
+  const style = tailwindClassesToStyle(classes, 'default', colorGroup);
+  if (style.bg) {
+    effects.push({ property: 'background', value: style.bg, token: style.bgToken });
+  }
+  if (style.border) {
+    effects.push({ property: 'border', value: style.border, token: style.borderToken });
+  }
+  if (style.text) {
+    effects.push({ property: 'text', value: style.text, token: style.textToken });
+  }
+  if (style.opacity != null) {
+    effects.push({ property: 'opacity', value: String(style.opacity) });
+  }
+  if (style.underline) {
+    effects.push({ property: 'underline', value: 'true' });
+  }
+  return effects;
+}
+
+export function mergeStatesWithDefinition(extracted: StateInfo[], defined: any): 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(),
+      effects: entry.effects,
+    };
+  }
+
+  const definedStates = defined.states || {};
+  for (const stateName in definedStates) {
+    const defEntry = definedStates[stateName];
+    const defClasses = defEntry && defEntry.classes ? defEntry.classes : [];
+    if (!map[stateName]) {
+      map[stateName] = {
+        name: stateName,
+        trigger: stateName + ':',
+        classes: defClasses.slice(),
+      };
+      continue;
+    }
+    if (defClasses.length > 0) {
+      map[stateName].classes = map[stateName].classes.concat(defClasses);
+    }
+  }
+
+  return Object.keys(map).map(key => map[key]);
+}