@starklab/stark-mcp 0.1.0

package/src/adopt/rnTokenAliasResolver.test.js

@@ -0,0 +1,260 @@
+import { mkdtempSync, rmSync, mkdirSync, writeFileSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+import { describe, it, expect, afterEach } from 'vitest';
+
+import { resolveRnTokenAliases } from './rnTokenAliasResolver.js';
+
+let tmpDirs = [];
+
+afterEach(() => {
+  for (const dir of tmpDirs) rmSync(dir, { recursive: true, force: true });
+  tmpDirs = [];
+});
+
+function fixture(files) {
+  const root = mkdtempSync(path.join(os.tmpdir(), 'stark-adopt-rn-alias-'));
+  tmpDirs.push(root);
+  for (const [rel, content] of Object.entries(files)) {
+    const full = path.join(root, rel);
+    mkdirSync(path.dirname(full), { recursive: true });
+    writeFileSync(full, content);
+  }
+  return root;
+}
+
+function usage(result, stkToken) {
+  return result.usages.find((u) => u.stkToken === stkToken);
+}
+
+function property(result, name) {
+  const found = result.properties.find((p) => p.name === name);
+  if (!found) throw new Error(`No property "${name}" in result. Found: ${result.properties.map((p) => p.name).join(', ')}`);
+  return found;
+}
+
+function findingsFor(result, rule, propName) {
+  return result.findings.filter((f) => f.rule === rule && f.property === propName);
+}
+
+describe('resolveRnTokenAliases — detection', () => {
+  it('reports detected:false with no report when no file imports a Stark RN token package', () => {
+    const root = fixture({
+      'src/App.js': `
+        import { StyleSheet } from 'react-native';
+        const styles = StyleSheet.create({ container: { backgroundColor: '#1956dd' } });
+      `,
+    });
+    const result = resolveRnTokenAliases(root, { platform: 'native' });
+    expect(result.detected).toBe(false);
+    expect(result.report).toBeNull();
+  });
+
+  it('detects an import from @starklab/stk/rn even if unused elsewhere', () => {
+    const root = fixture({
+      'src/App.js': `
+        import { stkSurfaceBrand1Strong } from '@starklab/stk/rn';
+      `,
+    });
+    const result = resolveRnTokenAliases(root, { platform: 'native' });
+    expect(result.detected).toBe(true);
+    expect(result.confidence).toBe('uncertain');
+  });
+});
+
+describe('resolveRnTokenAliases — usage classification (Pass 2)', () => {
+  it('classifies a directly-imported token referenced with no indirection as direct', () => {
+    const root = fixture({
+      'src/App.js': `
+        import { StyleSheet } from 'react-native';
+        import { stkSurfaceBrand1Strong } from '@starklab/stk/rn';
+        const styles = StyleSheet.create({ container: { backgroundColor: stkSurfaceBrand1Strong } });
+      `,
+    });
+    const result = resolveRnTokenAliases(root, { platform: 'native' });
+    expect(usage(result, 'stkSurfaceBrand1Strong').classification).toBe('direct');
+    expect(result.report.direct).toBe(1);
+  });
+
+  it('classifies a reference through a scalar local const alias as aliased', () => {
+    const root = fixture({
+      'src/App.js': `
+        import { StyleSheet } from 'react-native';
+        import { stkSurfaceBrand1Strong } from '@starklab/stk/rn';
+        const primary = stkSurfaceBrand1Strong;
+        const styles = StyleSheet.create({ container: { backgroundColor: primary } });
+      `,
+    });
+    const result = resolveRnTokenAliases(root, { platform: 'native' });
+    const u = result.usages.find((x) => x.ref === 'primary');
+    expect(u.classification).toBe('aliased');
+    expect(result.report.aliased).toBe(1);
+  });
+
+  it('classifies a reference through an object-literal property alias as aliased', () => {
+    const root = fixture({
+      'src/App.js': `
+        import { StyleSheet } from 'react-native';
+        import { stkSurfaceBrand1Strong } from '@starklab/stk/rn';
+        const theme = { primary: stkSurfaceBrand1Strong };
+        const styles = StyleSheet.create({ container: { backgroundColor: theme.primary } });
+      `,
+    });
+    const result = resolveRnTokenAliases(root, { platform: 'native' });
+    const u = result.usages.find((x) => x.ref === 'theme.primary');
+    expect(u.classification).toBe('aliased');
+  });
+
+  it('classifies a reference through a raw-literal object alias as drift, not aliased', () => {
+    const root = fixture({
+      'src/App.js': `
+        import { StyleSheet } from 'react-native';
+        import { stkSpacingMd } from '@starklab/stk/rn-spacing'; // unused, only to satisfy detection
+        const theme = { primary: '#1956dd' };
+        const styles = StyleSheet.create({ container: { backgroundColor: theme.primary } });
+      `,
+    });
+    const result = resolveRnTokenAliases(root, { platform: 'native' });
+    const p = property(result, 'theme.primary');
+    expect(p.state).toBe('drift');
+    const u = result.usages.find((x) => x.ref === 'theme.primary');
+    expect(u.classification).toBe('drift');
+    expect(findingsFor(result, 'drift-behind-alias', 'theme.primary')).toHaveLength(1);
+  });
+
+  it('classifies a reference through an alias to a foreign (non-Stark) import as broken', () => {
+    const root = fixture({
+      'src/App.js': `
+        import { StyleSheet } from 'react-native';
+        import { stkSpacingMd } from '@starklab/stk/rn-spacing'; // unused, only to satisfy detection
+        import { someColor } from 'some-other-lib';
+        const theme = { primary: someColor };
+        const styles = StyleSheet.create({ container: { backgroundColor: theme.primary } });
+      `,
+    });
+    const result = resolveRnTokenAliases(root, { platform: 'native' });
+    const p = property(result, 'theme.primary');
+    expect(p.state).toBe('broken');
+    expect(findingsFor(result, 'broken-alias', 'theme.primary')).toHaveLength(1);
+  });
+
+  it('applies the name-only heuristic when the containing object has no static origin (e.g. a useTokens() hook)', () => {
+    const root = fixture({
+      'src/App.js': `
+        import { StyleSheet } from 'react-native';
+        import { stkSpacingMd } from '@starklab/stk/rn-spacing'; // unused, only to satisfy detection
+        import { useTokens } from '../theme/ThemeContext';
+        function useStyles() {
+          const t = useTokens();
+          return StyleSheet.create({ container: { backgroundColor: t.stkSurfaceBrand1Strong } });
+        }
+      `,
+    });
+    const result = resolveRnTokenAliases(root, { platform: 'native' });
+    const u = usage(result, 'stkSurfaceBrand1Strong');
+    expect(u.classification).toBe('direct');
+    expect(u.heuristic).toBe(true);
+  });
+
+  it('does not count an unrelated member/identifier access as a usage', () => {
+    const root = fixture({
+      'src/App.js': `
+        import { StyleSheet } from 'react-native';
+        import { stkSpacingMd } from '@starklab/stk/rn-spacing'; // unused, only to satisfy detection
+        const styles = StyleSheet.create({ container: { flexDirection: 'row' } });
+      `,
+    });
+    const result = resolveRnTokenAliases(root, { platform: 'native' });
+    expect(result.report.total).toBe(0);
+  });
+});
+
+describe('resolveRnTokenAliases — layer violations', () => {
+  it('flags a scalar alias resolving straight to a primitive RN token', () => {
+    const root = fixture({
+      'src/App.js': `
+        import { StyleSheet } from 'react-native';
+        import { stkSpacingMd } from '@starklab/stk/rn-spacing';
+        const gap = stkSpacingMd;
+        const styles = StyleSheet.create({ container: { padding: gap } });
+      `,
+    });
+    const result = resolveRnTokenAliases(root, { platform: 'native' });
+    const p = property(result, 'gap');
+    expect(p.state).toBe('conformant');
+    const findings = findingsFor(result, 'layer-violation', 'gap');
+    expect(findings).toHaveLength(1);
+    expect(findings[0].severity).toBe('critical');
+  });
+});
+
+describe('resolveRnTokenAliases — depth', () => {
+  it('warns past ~3 hops on a multi-hop conformant scalar chain', () => {
+    const root = fixture({
+      'src/App.js': `
+        import { StyleSheet } from 'react-native';
+        import { stkSurfaceBrand1Strong } from '@starklab/stk/rn';
+        const hop4 = stkSurfaceBrand1Strong;
+        const hop3 = hop4;
+        const hop2 = hop3;
+        const hop1 = hop2;
+        const styles = StyleSheet.create({ container: { backgroundColor: hop1 } });
+      `,
+    });
+    const result = resolveRnTokenAliases(root, { platform: 'native' });
+    const p = property(result, 'hop1');
+    expect(p.state).toBe('conformant');
+    expect(findingsFor(result, 'deep-alias-chain', 'hop1')).toHaveLength(1);
+  });
+
+  it('does not warn on a short chain within the depth budget', () => {
+    const root = fixture({
+      'src/App.js': `
+        import { StyleSheet } from 'react-native';
+        import { stkSurfaceBrand1Strong } from '@starklab/stk/rn';
+        const hop2 = stkSurfaceBrand1Strong;
+        const hop1 = hop2;
+        const styles = StyleSheet.create({ container: { backgroundColor: hop1 } });
+      `,
+    });
+    const result = resolveRnTokenAliases(root, { platform: 'native' });
+    expect(findingsFor(result, 'deep-alias-chain', 'hop1')).toHaveLength(0);
+  });
+});
+
+describe('resolveRnTokenAliases — alias count and report', () => {
+  it('counts every distinct alias-graph entry and reports the three-number summary', () => {
+    const root = fixture({
+      'src/App.js': `
+        import { StyleSheet } from 'react-native';
+        import { stkSurfaceBrand1Strong } from '@starklab/stk/rn';
+        const primary = stkSurfaceBrand1Strong;
+        const secondary = '#1956dd';
+        const styles = StyleSheet.create({
+          a: { backgroundColor: stkSurfaceBrand1Strong },
+          b: { backgroundColor: primary },
+          c: { backgroundColor: secondary },
+        });
+      `,
+    });
+    const result = resolveRnTokenAliases(root, { platform: 'native' });
+    expect(result.aliasCount).toBe(2); // primary, secondary
+    expect(result.report.direct).toBe(1); // a
+    expect(result.report.aliased).toBe(1); // b
+    // c aliases a plain string local const — the alias graph tracked it (it's
+    // a real consumer-authored indirection), it just doesn't terminate at a
+    // Stark token, so it folds into "unresolved" same as CSS drift does on web.
+    expect(result.report.unresolved).toBe(1); // c
+    expect(result.report.total).toBe(3);
+  });
+});
+
+describe('resolveRnTokenAliases — platform scope', () => {
+  it('throws for a non-native platform since JS-object token indirection has no CSS/Tailwind equivalent', () => {
+    const root = fixture({
+      'src/App.js': `import { stkSurfaceBrand1Strong } from '@starklab/stk/rn';`,
+    });
+    expect(() => resolveRnTokenAliases(root, { platform: 'web' })).toThrow(/native/i);
+  });
+});