@tailwind-ts/eslint-plugin 0.1.0 → 0.3.0

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 };