inkhouse 0.1.0-beta.0

package/scanner/font-style-resolver-regression.ts

@@ -0,0 +1,32 @@
+import assert from 'node:assert/strict';
+import { inferFontWeight, rankStylesForRequest } from '../src/font-style-resolver';
+
+assert.equal(inferFontWeight('Regular'), 400);
+assert.equal(inferFontWeight('Medium'), 500);
+assert.equal(inferFontWeight('SemiBold'), 600);
+assert.equal(inferFontWeight('Demi Bold'), 600);
+assert.equal(inferFontWeight('Bold'), 700);
+assert.equal(inferFontWeight('ExtraBold'), 800);
+assert.equal(inferFontWeight('Black'), 900);
+assert.equal(inferFontWeight('Book'), 350);
+assert.equal(inferFontWeight('Weight 500'), 500);
+
+const mediumExact = rankStylesForRequest(['Regular', 'Medium', 'Bold'], 'Medium');
+assert.equal(mediumExact[0], 'Medium');
+
+const mediumFallback = rankStylesForRequest(['Regular', 'DemiBold', 'Bold'], 'Medium');
+assert.equal(mediumFallback[0], 'DemiBold');
+
+const mediumTiePrefersHeavier = rankStylesForRequest(['Regular', 'SemiBold'], 'Medium');
+assert.equal(mediumTiePrefersHeavier[0], 'SemiBold');
+
+const semiboldExactBeatsCondensed = rankStylesForRequest(['Condensed SemiBold', 'SemiBold', 'Regular'], 'SemiBold');
+assert.equal(semiboldExactBeatsCondensed[0], 'SemiBold');
+
+const semiBold = rankStylesForRequest(['Regular', 'Book', 'Semibold', 'Bold'], 'SemiBold');
+assert.equal(semiBold[0], 'Semibold');
+
+const keepItalic = rankStylesForRequest(['Regular', 'Regular Italic', 'Medium Italic'], 'Medium Italic');
+assert.equal(keepItalic[0], 'Medium Italic');
+
+console.log('font style resolver regression passed');

package/scanner/index.ts

@@ -0,0 +1,9 @@
+/**
+ * Component Scanner Module
+ *
+ * Exports all scanner functionality for programmatic use
+ */
+
+export * from './types';
+export * from './tailwind-parser';
+export { ComponentScanner } from './component-scanner';

package/scanner/radial-gradient-regression.ts

@@ -0,0 +1,53 @@
+import assert from 'node:assert/strict';
+import { parseRadialAnchorFromUtility, radialGradientTransformFromAnchor } from '../src/radial-gradient';
+
+function approxEqual(actual: number, expected: number, epsilon = 0.0001): void {
+  assert.ok(Math.abs(actual - expected) <= epsilon, `expected ${expected}, got ${actual}`);
+}
+
+function assertMatrix(
+  actual: [[number, number, number], [number, number, number]],
+  expected: [[number, number, number], [number, number, number]],
+): void {
+  approxEqual(actual[0][0], expected[0][0]);
+  approxEqual(actual[0][1], expected[0][1]);
+  approxEqual(actual[0][2], expected[0][2]);
+  approxEqual(actual[1][0], expected[1][0]);
+  approxEqual(actual[1][1], expected[1][1]);
+  approxEqual(actual[1][2], expected[1][2]);
+}
+
+// Default Tailwind `bg-radial` == CSS `radial-gradient(...)`
+// -> ellipse farthest-corner at center.
+const defaultTransform = radialGradientTransformFromAnchor({ x: 0.5, y: 0.5 });
+assertMatrix(defaultTransform, [
+  [Math.SQRT2 / 2, 0, 0.5 - ((Math.SQRT2 / 2) * 0.5)],
+  [0, Math.SQRT2 / 2, 0.5 - ((Math.SQRT2 / 2) * 0.5)],
+]);
+
+const topLeft = parseRadialAnchorFromUtility('bg-radial-[at_top_left]');
+assert.deepEqual(topLeft, { x: 0, y: 0 });
+
+const percent = parseRadialAnchorFromUtility('bg-radial-[at_25%_75%]');
+assert.deepEqual(percent, { x: 0.25, y: 0.75 });
+
+if (!topLeft || !percent) {
+  throw new Error('anchor parsing failed unexpectedly');
+}
+
+const topLeftTransform = radialGradientTransformFromAnchor(topLeft);
+const topLeftScale = 0.5 / Math.SQRT2;
+assertMatrix(topLeftTransform, [
+  [topLeftScale, 0, 0.5],
+  [0, topLeftScale, 0.5],
+]);
+
+const percentTransform = radialGradientTransformFromAnchor(percent);
+const expectedPercentRadius = Math.sqrt((0.75 * 0.75) + (0.75 * 0.75));
+const expectedPercentScale = 0.5 / expectedPercentRadius;
+assertMatrix(percentTransform, [
+  [expectedPercentScale, 0, 0.5 - (expectedPercentScale * 0.25)],
+  [0, expectedPercentScale, 0.5 - (expectedPercentScale * 0.75)],
+]);
+
+console.log('radial gradient regression passed');

package/scanner/style-map.ts

@@ -0,0 +1,145 @@
+import fs from 'fs';
+import path from 'path';
+import postcss, { AtRule, Declaration, Rule } from 'postcss';
+import { compile } from 'tailwindcss';
+
+export interface StyleRuleEntry {
+  declarations: Record<string, string>;
+  media?: string;
+}
+
+export type StyleMap = Record<string, StyleRuleEntry[]>;
+
+async function loadStylesheet(id: string, base: string): Promise<{ path: string; base: string; content: string }> {
+  const root = process.cwd();
+  let filePath: string;
+
+  if (id.startsWith('.')) {
+    filePath = path.resolve(base, id);
+    if (!fs.existsSync(filePath)) {
+      filePath = path.resolve(root, 'src/app', id);
+    }
+  } else if (id === 'tailwindcss') {
+    filePath = path.resolve(root, 'node_modules/tailwindcss/index.css');
+  } else if (id === 'tw-animate-css') {
+    filePath = path.resolve(root, 'node_modules/tw-animate-css/dist/tw-animate.css');
+  } else {
+    filePath = path.resolve(root, 'node_modules', id);
+  }
+
+  const content = fs.readFileSync(filePath, 'utf-8');
+  return { path: filePath, base: path.dirname(filePath), content };
+}
+
+function extractClassName(selector: string): string | null {
+  const dot = selector.indexOf('.');
+  if (dot === -1) return null;
+  let out = '';
+  for (let i = dot + 1; i < selector.length; i++) {
+    const ch = selector[i];
+    if (ch === '\\') {
+      if (i + 1 < selector.length) {
+        out += selector[i + 1];
+        i++;
+        continue;
+      }
+    }
+    if (
+      ch === ':' ||
+      ch === ' ' ||
+      ch === '\n' ||
+      ch === '\t' ||
+      ch === '>' ||
+      ch === '+' ||
+      ch === '~' ||
+      ch === ',' ||
+      ch === ')' ||
+      ch === '['
+    ) {
+      break;
+    }
+    out += ch;
+  }
+  return out || null;
+}
+
+function addToMap(
+  map: StyleMap,
+  className: string,
+  declarations: Record<string, string>,
+  media?: string
+): void {
+  if (!map[className]) map[className] = [];
+  map[className].push({ declarations, media });
+}
+
+function walkNodes(
+  node: postcss.Container,
+  selectors: string[],
+  media: string[],
+  candidates: Set<string>,
+  map: StyleMap
+): void {
+  node.nodes?.forEach(child => {
+    if (child.type === 'rule') {
+      const rule = child as Rule;
+      const ruleSelectors = rule.selectors || [rule.selector];
+      const expanded = ruleSelectors.flatMap(sel => {
+        if (sel.includes('&') && selectors.length > 0) {
+          return selectors.map(parent => sel.replace(/&/g, parent));
+        }
+        return [sel];
+      });
+
+      const decls: Record<string, string> = {};
+      rule.nodes?.forEach(ruleChild => {
+        if (ruleChild.type === 'decl') {
+          const decl = ruleChild as Declaration;
+          if (decl.prop.startsWith('--tw-')) return;
+          decls[decl.prop] = decl.important ? `${decl.value} !important` : decl.value;
+        }
+      });
+
+      if (Object.keys(decls).length > 0) {
+        for (const sel of expanded) {
+          const className = extractClassName(sel);
+          if (!className) continue;
+          if (!candidates.has(className)) continue;
+          addToMap(map, className, decls, media.length > 0 ? media.join(' && ') : undefined);
+        }
+      }
+
+      walkNodes(rule, expanded, media, candidates, map);
+      return;
+    }
+
+    if (child.type === 'atrule') {
+      const at = child as AtRule;
+      if (at.name === 'media' || at.name === 'supports') {
+        walkNodes(at, selectors, media.concat(`${at.name} ${at.params}`), candidates, map);
+      } else {
+        walkNodes(at, selectors, media, candidates, map);
+      }
+      return;
+    }
+  });
+}
+
+export async function buildStyleMap(classes: string[]): Promise<StyleMap> {
+  const unique = Array.from(new Set(classes.filter(Boolean)));
+  if (unique.length === 0) return {};
+
+  const css = fs.readFileSync(path.resolve(process.cwd(), 'src/app/globals.css'), 'utf-8');
+  const compiled = await compile(css, {
+    base: process.cwd(),
+    loadStylesheet,
+  });
+
+  const cssOutput = compiled.build(unique);
+  const root = postcss.parse(cssOutput);
+  const map: StyleMap = {};
+  const candidateSet = new Set(unique);
+
+  walkNodes(root, [], [], candidateSet, map);
+  return map;
+}