@nekoyasuii/config 0.1.0

package/dist/tools/oxlint/config/remix/index.d.ts

@@ -0,0 +1,11 @@
+declare const _default: {
+    overrides: {
+        files: string[];
+        rules: {
+            "unicorn/filename-case": "off";
+            "unicorn/no-abusive-eslint-disable": "off";
+        };
+    }[];
+    rules: {};
+};
+export default _default;

package/dist/tools/oxlint/config/remix/index.js

@@ -0,0 +1,19 @@
+import"../../../../chunk-5wgwscd0.js";
+
+// tools/oxlint/config/remix/index.ts
+import { defineConfig } from "oxlint";
+var remix_default = defineConfig({
+  overrides: [
+    {
+      files: ["**/routeTree.gen.ts"],
+      rules: {
+        "unicorn/filename-case": "off",
+        "unicorn/no-abusive-eslint-disable": "off"
+      }
+    }
+  ],
+  rules: {}
+});
+export {
+  remix_default as default
+};

package/dist/tools/oxlint/config/tanstack/index.d.ts

@@ -0,0 +1,17 @@
+export declare const tanstackConfig: {
+    overrides: ({
+        files: string[];
+        rules: {
+            "sort-keys": "off";
+            "unicorn/filename-case": "off";
+            "unicorn/no-abusive-eslint-disable"?: undefined;
+        };
+    } | {
+        files: string[];
+        rules: {
+            "sort-keys"?: undefined;
+            "unicorn/filename-case": "off";
+            "unicorn/no-abusive-eslint-disable": "off";
+        };
+    })[];
+};

package/dist/tools/oxlint/config/tanstack/index.js

@@ -0,0 +1,25 @@
+import"../../../../chunk-5wgwscd0.js";
+
+// tools/oxlint/config/tanstack/index.ts
+import { defineConfig } from "oxlint";
+var tanstackConfig = defineConfig({
+  overrides: [
+    {
+      files: ["**/routes/**/*.{tsx,ts}", "**/app/routes/**/*.{tsx,ts}"],
+      rules: {
+        "sort-keys": "off",
+        "unicorn/filename-case": "off"
+      }
+    },
+    {
+      files: ["**/routeTree.gen.ts"],
+      rules: {
+        "unicorn/filename-case": "off",
+        "unicorn/no-abusive-eslint-disable": "off"
+      }
+    }
+  ]
+});
+export {
+  tanstackConfig
+};

package/dist/tools/oxlint/config/tanstack/js-plugins/index.d.ts

@@ -0,0 +1,30 @@
+declare const _default: {
+    jsPlugins: {
+        name: string;
+        specifier: string;
+    }[];
+    rules: {
+        "react-doctor/query-destructure-result": "error";
+        "react-doctor/query-mutation-missing-invalidation": "error";
+        "react-doctor/query-no-query-in-effect": "error";
+        "react-doctor/query-no-rest-destructuring": "error";
+        "react-doctor/query-no-usequery-for-mutation": "error";
+        "react-doctor/query-no-void-query-fn": "error";
+        "react-doctor/query-stable-query-client": "error";
+        "react-doctor/tanstack-start-get-mutation": "error";
+        "react-doctor/tanstack-start-loader-parallel-fetch": "error";
+        "react-doctor/tanstack-start-missing-head-content": "error";
+        "react-doctor/tanstack-start-no-anchor-element": "error";
+        "react-doctor/tanstack-start-no-direct-fetch-in-loader": "error";
+        "react-doctor/tanstack-start-no-dynamic-server-fn-import": "error";
+        "react-doctor/tanstack-start-no-navigate-in-render": "error";
+        "react-doctor/tanstack-start-no-secrets-in-loader": "error";
+        "react-doctor/tanstack-start-no-use-server-in-handler": "error";
+        "react-doctor/tanstack-start-no-useeffect-fetch": "error";
+        "react-doctor/tanstack-start-redirect-in-try-catch": "error";
+        "react-doctor/tanstack-start-route-property-order": "error";
+        "react-doctor/tanstack-start-server-fn-method-order": "error";
+        "react-doctor/tanstack-start-server-fn-validate-input": "error";
+    };
+};
+export default _default;

package/dist/tools/oxlint/config/tanstack/js-plugins/index.js

@@ -0,0 +1,33 @@
+import"../../../../../chunk-5wgwscd0.js";
+
+// tools/oxlint/config/tanstack/js-plugins/index.ts
+import { defineConfig } from "oxlint";
+var js_plugins_default = defineConfig({
+  jsPlugins: [{ name: "react-doctor", specifier: "oxlint-plugin-react-doctor" }],
+  rules: {
+    "react-doctor/query-destructure-result": "error",
+    "react-doctor/query-mutation-missing-invalidation": "error",
+    "react-doctor/query-no-query-in-effect": "error",
+    "react-doctor/query-no-rest-destructuring": "error",
+    "react-doctor/query-no-usequery-for-mutation": "error",
+    "react-doctor/query-no-void-query-fn": "error",
+    "react-doctor/query-stable-query-client": "error",
+    "react-doctor/tanstack-start-get-mutation": "error",
+    "react-doctor/tanstack-start-loader-parallel-fetch": "error",
+    "react-doctor/tanstack-start-missing-head-content": "error",
+    "react-doctor/tanstack-start-no-anchor-element": "error",
+    "react-doctor/tanstack-start-no-direct-fetch-in-loader": "error",
+    "react-doctor/tanstack-start-no-dynamic-server-fn-import": "error",
+    "react-doctor/tanstack-start-no-navigate-in-render": "error",
+    "react-doctor/tanstack-start-no-secrets-in-loader": "error",
+    "react-doctor/tanstack-start-no-use-server-in-handler": "error",
+    "react-doctor/tanstack-start-no-useeffect-fetch": "error",
+    "react-doctor/tanstack-start-redirect-in-try-catch": "error",
+    "react-doctor/tanstack-start-route-property-order": "error",
+    "react-doctor/tanstack-start-server-fn-method-order": "error",
+    "react-doctor/tanstack-start-server-fn-validate-input": "error"
+  }
+});
+export {
+  js_plugins_default as default
+};

package/dist/tools/oxlint/rules/index.d.ts

@@ -0,0 +1,2 @@
+declare const plugin: import("@oxlint/plugins").Plugin;
+export default plugin;

package/dist/tools/oxlint/rules/index.js

@@ -0,0 +1,482 @@
+import"../../../chunk-5wgwscd0.js";
+
+// node_modules/@oxlint/plugins/index.js
+function definePlugin(plugin) {
+  return plugin;
+}
+function defineRule(rule) {
+  return rule;
+}
+var FILE_CONTEXT = Object.freeze({
+  get filename() {
+    throw Error("Cannot access `context.filename` in `createOnce`");
+  },
+  getFilename() {
+    throw Error("Cannot call `context.getFilename` in `createOnce`");
+  },
+  get physicalFilename() {
+    throw Error("Cannot access `context.physicalFilename` in `createOnce`");
+  },
+  getPhysicalFilename() {
+    throw Error("Cannot call `context.getPhysicalFilename` in `createOnce`");
+  },
+  get cwd() {
+    throw Error("Cannot access `context.cwd` in `createOnce`");
+  },
+  getCwd() {
+    throw Error("Cannot call `context.getCwd` in `createOnce`");
+  },
+  get sourceCode() {
+    throw Error("Cannot access `context.sourceCode` in `createOnce`");
+  },
+  getSourceCode() {
+    throw Error("Cannot call `context.getSourceCode` in `createOnce`");
+  },
+  get languageOptions() {
+    throw Error("Cannot access `context.languageOptions` in `createOnce`");
+  },
+  get settings() {
+    throw Error("Cannot access `context.settings` in `createOnce`");
+  },
+  extend(extension) {
+    return Object.freeze(Object.assign(Object.create(this), extension));
+  },
+  get parserOptions() {
+    throw Error("Cannot access `context.parserOptions` in `createOnce`");
+  },
+  get parserPath() {
+    throw Error("Cannot access `context.parserPath` in `createOnce`");
+  }
+});
+
+// tools/oxlint/rules/prefer-alias/rule.ts
+import fs2 from "node:fs";
+import path2 from "node:path";
+
+// tools/shared/tsconfig-aliases.ts
+import fs from "node:fs";
+import path from "node:path";
+var emptyConfig = { aliasPatterns: {}, basePath: "" };
+function readStringLiteral(source, start) {
+  let index = start + 1;
+  while (index < source.length) {
+    const char = source[index];
+    if (char === "\\") {
+      index += 2;
+      continue;
+    }
+    index += 1;
+    if (char === `"`)
+      break;
+  }
+  return index;
+}
+function skipComment(source, index) {
+  const char = source[index];
+  const next = source[index + 1];
+  if (char !== "/" || next !== "/" && next !== "*")
+    return index;
+  if (next === "/") {
+    let end2 = index + 2;
+    while (end2 < source.length && source[end2] !== `
+`)
+      end2 += 1;
+    return end2;
+  }
+  let end = index + 2;
+  while (end < source.length && !(source[end] === "*" && source[end + 1] === "/"))
+    end += 1;
+  return end + 2;
+}
+function skipWhitespace(source, index) {
+  let end = index;
+  while (end < source.length && /\s/u.test(source[end]))
+    end += 1;
+  return end;
+}
+function closesCollection(source, index) {
+  const next = source[skipWhitespace(source, index)];
+  return next === "}" || next === "]";
+}
+function stripJsonComments(source) {
+  const { length } = source;
+  const parts = [];
+  let chunkStart = 0;
+  let index = 0;
+  while (index < length) {
+    const char = source[index];
+    if (char === `"`) {
+      index = readStringLiteral(source, index);
+      continue;
+    }
+    const commentEnd = skipComment(source, index);
+    if (commentEnd !== index) {
+      parts.push(source.slice(chunkStart, index));
+      index = commentEnd;
+      chunkStart = index;
+      continue;
+    }
+    if (char === "," && closesCollection(source, index + 1)) {
+      parts.push(source.slice(chunkStart, index));
+      index += 1;
+      chunkStart = index;
+      continue;
+    }
+    index += 1;
+  }
+  parts.push(source.slice(chunkStart));
+  return parts.join("");
+}
+function resolveExtendsPath(fromFile, parent) {
+  if (!parent.startsWith(".") && !path.isAbsolute(parent)) {
+    return null;
+  }
+  const resolved = path.resolve(path.dirname(fromFile), parent);
+  if (fs.existsSync(resolved))
+    return resolved;
+  const withExtension = `${resolved.replace(/\.json$/u, "")}.json`;
+  return fs.existsSync(withExtension) ? withExtension : null;
+}
+function parseTsConfigFile(filePath, seen) {
+  if (seen.has(filePath))
+    return {};
+  seen.add(filePath);
+  const parsed = JSON.parse(stripJsonComments(fs.readFileSync(filePath, "utf-8")));
+  const parents = typeof parsed.extends === "string" ? [parsed.extends] : parsed.extends ?? [];
+  let merged = {};
+  for (const parent of parents) {
+    const parentPath = resolveExtendsPath(filePath, parent);
+    if (!parentPath)
+      continue;
+    merged = parseTsConfigFile(parentPath, seen);
+  }
+  return {
+    ...merged,
+    ...parsed,
+    compilerOptions: { ...merged.compilerOptions, ...parsed.compilerOptions }
+  };
+}
+var configCache = new Map;
+function loadTsConfigAliases(cwd) {
+  const tsconfigPath = path.resolve(cwd, "tsconfig.json");
+  if (!fs.existsSync(tsconfigPath))
+    return emptyConfig;
+  try {
+    const mtime = fs.statSync(tsconfigPath).mtimeMs;
+    const cached = configCache.get(tsconfigPath);
+    if (cached && cached.mtime === mtime)
+      return cached.config;
+    const tsconfig = parseTsConfigFile(tsconfigPath, new Set);
+    const config = {
+      aliasPatterns: tsconfig.compilerOptions?.paths ?? {},
+      basePath: path.resolve(path.dirname(tsconfigPath), tsconfig.compilerOptions?.baseUrl ?? ".")
+    };
+    configCache.set(tsconfigPath, { mtime, config });
+    return config;
+  } catch (error) {
+    console.error(`prefer-alias: could not read ${tsconfigPath}: ${String(error)}`);
+    return emptyConfig;
+  }
+}
+
+// tools/oxlint/rules/prefer-alias/rule.ts
+var moduleExtensions = [
+  ".ts",
+  ".tsx",
+  ".mts",
+  ".cts",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".json"
+];
+var fileCheckCache = new Map;
+function isFile(absolutePath) {
+  const cached = fileCheckCache.get(absolutePath);
+  if (cached !== undefined)
+    return cached;
+  let exists;
+  try {
+    exists = fs2.statSync(absolutePath).isFile();
+  } catch {
+    exists = false;
+  }
+  fileCheckCache.set(absolutePath, exists);
+  return exists;
+}
+var resolutionCache = new Map;
+function resolveModulePath(absolutePath) {
+  const cached = resolutionCache.get(absolutePath);
+  if (cached !== undefined)
+    return cached;
+  let resolved = null;
+  if (isFile(absolutePath))
+    resolved = absolutePath;
+  else {
+    for (const extension of moduleExtensions) {
+      if (isFile(`${absolutePath}${extension}`)) {
+        resolved = `${absolutePath}${extension}`;
+        break;
+      }
+    }
+  }
+  if (!resolved) {
+    for (const extension of moduleExtensions) {
+      const candidate = path2.join(absolutePath, `index${extension}`);
+      if (isFile(candidate)) {
+        resolved = candidate;
+        break;
+      }
+    }
+  }
+  resolutionCache.set(absolutePath, resolved);
+  return resolved;
+}
+function capturePathRemainder(absolutePath, basePath, pathPattern) {
+  const wildcardIndex = pathPattern.indexOf("*");
+  if (wildcardIndex === -1)
+    return absolutePath === path2.resolve(basePath, pathPattern) ? "" : null;
+  const head = pathPattern.slice(0, wildcardIndex);
+  const tail = pathPattern.slice(wildcardIndex + 1);
+  const resolvedHead = path2.normalize(path2.resolve(basePath, head));
+  const prefix = resolvedHead.endsWith(path2.sep) ? resolvedHead : `${resolvedHead}${path2.sep}`;
+  if (!absolutePath.startsWith(prefix))
+    return null;
+  let remainder = absolutePath.slice(prefix.length);
+  if (tail) {
+    if (!remainder.endsWith(tail) || remainder.length === tail.length)
+      return null;
+    remainder = remainder.slice(0, remainder.length - tail.length);
+  }
+  return remainder.replaceAll(path2.sep, "/");
+}
+function collectAliasCandidates(absolutePath, basePath, aliasPatterns) {
+  const candidates = [];
+  for (const [aliasPattern, pathPatterns] of Object.entries(aliasPatterns)) {
+    const aliasWildcard = aliasPattern.indexOf("*");
+    for (const pathPattern of pathPatterns) {
+      const remainder = capturePathRemainder(absolutePath, basePath, pathPattern);
+      if (remainder === null)
+        continue;
+      if (aliasWildcard === -1) {
+        if (remainder === "")
+          candidates.push(aliasPattern);
+        continue;
+      }
+      candidates.push(aliasPattern.slice(0, aliasWildcard) + remainder);
+    }
+  }
+  return candidates;
+}
+function findBestAliasMatch(absolutePath, basePath, aliasPatterns) {
+  const candidates = collectAliasCandidates(absolutePath, basePath, aliasPatterns);
+  let shortest = null;
+  for (const candidate of candidates)
+    if (shortest === null || candidate.length < shortest.length)
+      shortest = candidate;
+  return shortest;
+}
+function findAliasTarget(importPath, basePath, aliasPatterns) {
+  const candidates = [];
+  for (const [aliasPattern, pathPatterns] of Object.entries(aliasPatterns)) {
+    const aliasWildcard = aliasPattern.indexOf("*");
+    if (aliasWildcard === -1) {
+      if (importPath === aliasPattern) {
+        const [pathPattern] = pathPatterns;
+        if (pathPattern)
+          candidates.push(path2.resolve(basePath, pathPattern));
+      }
+      continue;
+    }
+    const aliasBase = aliasPattern.slice(0, aliasWildcard);
+    if (!importPath.startsWith(aliasBase))
+      continue;
+    const remainder = importPath.slice(aliasBase.length);
+    for (const pathPattern of pathPatterns) {
+      const pathWildcardIndex = pathPattern.indexOf("*");
+      if (pathWildcardIndex === -1)
+        continue;
+      candidates.push(path2.resolve(basePath, `${pathPattern.slice(0, pathWildcardIndex)}${remainder}${pathPattern.slice(pathWildcardIndex + 1)}`));
+    }
+  }
+  if (candidates.length === 0)
+    return null;
+  return candidates.find((candidate) => resolveModulePath(candidate)) ?? candidates[0];
+}
+function matchesAliasPattern(importPath, aliasPatterns) {
+  for (const aliasPattern of Object.keys(aliasPatterns)) {
+    const wildcardIndex = aliasPattern.indexOf("*");
+    if (wildcardIndex === -1) {
+      if (importPath === aliasPattern)
+        return true;
+      continue;
+    }
+    const head = aliasPattern.slice(0, wildcardIndex);
+    const tail = aliasPattern.slice(wildcardIndex + 1);
+    if (tail) {
+      if (importPath.endsWith(tail) && importPath.length >= head.length + tail.length)
+        return true;
+      continue;
+    }
+    if (importPath.startsWith(head) && importPath.length > head.length)
+      return true;
+  }
+  return false;
+}
+var packageNameCache = new Map;
+function pathExists(absolutePath) {
+  try {
+    fs2.statSync(absolutePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isInstalledPackage(importPath, cwd, exists = pathExists) {
+  const segments = importPath.split("/");
+  const packageName = importPath.startsWith("@") ? segments.slice(0, 2).join("/") : segments[0];
+  if (!packageName)
+    return false;
+  const cacheKey = `${cwd}
+${packageName}`;
+  const cached = packageNameCache.get(cacheKey);
+  if (cached !== undefined)
+    return cached;
+  const installed = exists(path2.join(cwd, "node_modules", packageName));
+  packageNameCache.set(cacheKey, installed);
+  return installed;
+}
+function isSameDirectory(absolutePath, directory) {
+  return path2.dirname(absolutePath) === directory;
+}
+function toRelativeImport(importerDirectory, absolutePath) {
+  const relativePath = path2.relative(importerDirectory, absolutePath).replaceAll(path2.sep, "/");
+  return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
+}
+function isRelativeImport(importPath) {
+  return ["./", "../"].some((prefix) => importPath.startsWith(prefix)) || importPath === "." || importPath === "..";
+}
+function preserveExtensionOmission(original, suggested) {
+  const extension = path2.extname(suggested);
+  return extension !== "" && path2.extname(original) === "" ? suggested.slice(0, -extension.length) : suggested;
+}
+function parseOptionsAlias(option) {
+  if (typeof option !== "object" || option === null || Array.isArray(option))
+    return null;
+  const { alias } = option;
+  if (typeof alias !== "object" || alias === null || Array.isArray(alias))
+    return null;
+  const parsed = {};
+  for (const [key, value] of Object.entries(alias)) {
+    if (typeof value === "string") {
+      parsed[key] = [value];
+      continue;
+    }
+    if (Array.isArray(value) && value.every((item) => typeof item === "string"))
+      parsed[key] = value;
+  }
+  return parsed;
+}
+function loadAliasConfig(cwd, options) {
+  const loaded = loadTsConfigAliases(cwd);
+  const aliasPatterns = { ...loaded.aliasPatterns };
+  const configured = parseOptionsAlias(options[0]);
+  if (configured)
+    Object.assign(aliasPatterns, configured);
+  return { aliasPatterns, basePath: loaded.basePath || cwd };
+}
+function findShorterAlias(absolutePath, basePath, aliasPatterns, currentSpelling) {
+  const match = findBestAliasMatch(absolutePath, basePath, aliasPatterns);
+  if (!match || match === currentSpelling)
+    return null;
+  return preserveExtensionOmission(currentSpelling, match).length < currentSpelling.length ? match : null;
+}
+function hasStaticModuleSpecifier(node) {
+  return node.type === "ImportDeclaration" || node.type === "ExportNamedDeclaration" || node.type === "ExportAllDeclaration";
+}
+var preferAlias = defineRule({
+  createOnce: (context) => {
+    let config;
+    const checkModuleSpecifier = (node) => {
+      if (!hasStaticModuleSpecifier(node))
+        return;
+      const { source } = node;
+      if (!source)
+        return;
+      config ??= loadAliasConfig(context.cwd, context.options);
+      const { aliasPatterns, basePath } = config;
+      if (Object.keys(aliasPatterns).length === 0)
+        return;
+      const importPath = source.value;
+      const importerDirectory = path2.dirname(context.filename);
+      const relativeImport = isRelativeImport(importPath);
+      const absoluteImport = relativeImport ? resolveModulePath(path2.resolve(importerDirectory, importPath)) ?? path2.resolve(importerDirectory, importPath) : findAliasTarget(importPath, basePath, aliasPatterns);
+      if (!absoluteImport)
+        return;
+      const report = (candidate, messageId) => {
+        const newPath = preserveExtensionOmission(importPath, candidate);
+        context.report({
+          data: { newPath, path: importPath },
+          fix: (fixer) => fixer.replaceTextRange([source.range[0] + 1, source.range[1] - 1], newPath),
+          messageId,
+          node
+        });
+      };
+      if (!relativeImport) {
+        if (isInstalledPackage(importPath, context.cwd) || !matchesAliasPattern(importPath, aliasPatterns))
+          return;
+        if (isSameDirectory(absoluteImport, importerDirectory)) {
+          report(toRelativeImport(importerDirectory, absoluteImport), "import");
+          return;
+        }
+        const match2 = findShorterAlias(absoluteImport, basePath, aliasPatterns, importPath);
+        if (match2)
+          report(match2, "shortAlias");
+        return;
+      }
+      if (isSameDirectory(absoluteImport, importerDirectory))
+        return;
+      const match = findShorterAlias(absoluteImport, basePath, aliasPatterns, importPath);
+      if (match)
+        report(match, "import");
+    };
+    return {
+      ImportDeclaration: checkModuleSpecifier,
+      ExportAllDeclaration: checkModuleSpecifier,
+      ExportNamedDeclaration: checkModuleSpecifier
+    };
+  },
+  meta: {
+    defaultOptions: [{}],
+    fixable: "code",
+    messages: {
+      import: "Unexpected import {{path}}. Use {{newPath}} instead",
+      shortAlias: "Prefer importing {{newPath}} over {{path}}"
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          alias: {
+            description: "Optional map of additional aliases (overrides tsconfig.json if provided). Can be string or array of strings.",
+            type: "object"
+          }
+        },
+        type: "object"
+      }
+    ],
+    hasSuggestions: true,
+    type: "suggestion"
+  }
+});
+
+// tools/oxlint/rules/index.ts
+var plugin = definePlugin({
+  meta: { name: "lazuee" },
+  rules: { "prefer-alias": preferAlias }
+});
+var rules_default = plugin;
+export {
+  rules_default as default
+};

package/dist/tools/shared/ignores.d.ts

@@ -0,0 +1 @@
+export declare const ignorePatterns: string[];

package/dist/tools/shared/ignores.js

@@ -0,0 +1,7 @@
+import {
+  ignorePatterns
+} from "../../chunk-41590bpf.js";
+import"../../chunk-5wgwscd0.js";
+export {
+  ignorePatterns
+};

package/dist/tools/shared/tsconfig-aliases.d.ts

@@ -0,0 +1,11 @@
+export interface AliasConfig {
+    aliasPatterns: Record<string, string[]>;
+    /** Directory that `paths` entries are resolved against. */
+    basePath: string;
+}
+/**
+ * Removes `//` and block comments plus trailing commas, skipping the contents
+ * of string literals so values like "http://localhost" survive.
+ */
+export declare function stripJsonComments(source: string): string;
+export declare function loadTsConfigAliases(cwd: string): AliasConfig;

package/dist/tools/shared/types.d.ts

@@ -0,0 +1 @@
+export type RuleSeverity = "off" | "warn" | "error" | [RuleSeverity, ...unknown[]];