@shibanet0/datamitsu-config 0.0.1-alpha-9 → 0.0.1-alpha-11

package/dist/eslint/index.js

@@ -1,71 +1,970 @@
 // src/eslint/index.ts
-import eslint from "@eslint/js";
+import { FlatConfigComposer } from "eslint-flat-config-utils";
+import oxlint from "eslint-plugin-oxlint";
 import { defineConfig as eslintDefineConfig, globalIgnores } from "eslint/config";
-import tseslint from "typescript-eslint";
-var todoDisable = [
-  {
-    rules: {
-      "@typescript-eslint/no-explicit-any": "off",
-      "@typescript-eslint/no-unused-vars": "off",
-      "no-undef": "off"
+
+// package.json
+var name = "@shibanet0/datamitsu-config";
+
+// src/oxlint/index.ts
+var disabledRules = {
+  "no-unsafe-optional-chaining": "off",
+  "no-unused-vars": "off",
+  "no-useless-rename": "off",
+  "typescript/triple-slash-reference": "off",
+  "unicorn/no-single-promise-in-promise-methods": "off"
+};
+var oxlintConfig = {
+  $schema: `./node_modules/${name}/oxlint_configuration_schema.json`,
+  categories: {},
+  env: {
+    builtin: true
+  },
+  globals: {},
+  ignorePatterns: [],
+  plugins: ["unicorn", "typescript", "oxc"],
+  rules: {
+    "constructor-super": "warn",
+    "for-direction": "warn",
+    "no-async-promise-executor": "warn",
+    "no-caller": "warn",
+    "no-class-assign": "warn",
+    "no-compare-neg-zero": "warn",
+    "no-cond-assign": "warn",
+    "no-const-assign": "warn",
+    "no-constant-binary-expression": "warn",
+    "no-constant-condition": "warn",
+    "no-control-regex": "warn",
+    "no-debugger": "warn",
+    "no-delete-var": "warn",
+    "no-dupe-class-members": "warn",
+    "no-dupe-else-if": "warn",
+    "no-dupe-keys": "warn",
+    "no-duplicate-case": "warn",
+    "no-empty-character-class": "warn",
+    "no-empty-pattern": "warn",
+    "no-empty-static-block": "warn",
+    "no-eval": "warn",
+    "no-ex-assign": "warn",
+    "no-extra-boolean-cast": "warn",
+    "no-func-assign": "warn",
+    "no-global-assign": "warn",
+    "no-import-assign": "warn",
+    "no-invalid-regexp": "warn",
+    "no-irregular-whitespace": "warn",
+    "no-loss-of-precision": "warn",
+    "no-new-native-nonconstructor": "warn",
+    "no-nonoctal-decimal-escape": "warn",
+    "no-obj-calls": "warn",
+    "no-self-assign": "warn",
+    "no-setter-return": "warn",
+    "no-shadow-restricted-names": "warn",
+    "no-sparse-arrays": "warn",
+    "no-this-before-super": "warn",
+    "no-unassigned-vars": "warn",
+    "no-unsafe-finally": "warn",
+    "no-unsafe-negation": "warn",
+    "no-unsafe-optional-chaining": "warn",
+    "no-unused-expressions": "warn",
+    "no-unused-labels": "warn",
+    "no-unused-private-class-members": "warn",
+    "no-unused-vars": "warn",
+    "no-useless-backreference": "warn",
+    "no-useless-catch": "warn",
+    "no-useless-escape": "warn",
+    "no-useless-rename": "warn",
+    "no-with": "warn",
+    "oxc/bad-array-method-on-arguments": "warn",
+    "oxc/bad-char-at-comparison": "warn",
+    "oxc/bad-comparison-sequence": "warn",
+    "oxc/bad-min-max-func": "warn",
+    "oxc/bad-object-literal-comparison": "warn",
+    "oxc/bad-replace-all-arg": "warn",
+    "oxc/const-comparisons": "warn",
+    "oxc/double-comparisons": "warn",
+    "oxc/erasing-op": "warn",
+    "oxc/missing-throw": "warn",
+    "oxc/number-arg-out-of-range": "warn",
+    "oxc/only-used-in-recursion": "warn",
+    "oxc/uninvoked-array-callback": "warn",
+    "require-yield": "warn",
+    "typescript/await-thenable": "warn",
+    "typescript/no-array-delete": "warn",
+    "typescript/no-base-to-string": "warn",
+    "typescript/no-duplicate-enum-values": "warn",
+    "typescript/no-duplicate-type-constituents": "warn",
+    "typescript/no-extra-non-null-assertion": "warn",
+    "typescript/no-floating-promises": "warn",
+    "typescript/no-for-in-array": "warn",
+    "typescript/no-implied-eval": "warn",
+    "typescript/no-meaningless-void-operator": "warn",
+    "typescript/no-misused-new": "warn",
+    "typescript/no-misused-spread": "warn",
+    "typescript/no-non-null-asserted-optional-chain": "warn",
+    "typescript/no-redundant-type-constituents": "warn",
+    "typescript/no-this-alias": "warn",
+    "typescript/no-unnecessary-parameter-property-assignment": "warn",
+    "typescript/no-unsafe-declaration-merging": "warn",
+    "typescript/no-unsafe-unary-minus": "warn",
+    "typescript/no-useless-empty-export": "warn",
+    "typescript/no-wrapper-object-types": "warn",
+    "typescript/prefer-as-const": "warn",
+    "typescript/require-array-sort-compare": "warn",
+    "typescript/restrict-template-expressions": "warn",
+    "typescript/unbound-method": "warn",
+    "unicorn/no-await-in-promise-methods": "warn",
+    "unicorn/no-empty-file": "warn",
+    "unicorn/no-invalid-fetch-options": "warn",
+    "unicorn/no-invalid-remove-event-listener": "warn",
+    "unicorn/no-new-array": "warn",
+    "unicorn/no-single-promise-in-promise-methods": "warn",
+    "unicorn/no-thenable": "warn",
+    "unicorn/no-unnecessary-await": "warn",
+    "unicorn/no-useless-fallback-in-spread": "warn",
+    "unicorn/no-useless-length-check": "warn",
+    "unicorn/no-useless-spread": "warn",
+    "unicorn/prefer-set-size": "warn",
+    "unicorn/prefer-string-starts-ends-with": "warn",
+    "use-isnan": "warn",
+    "valid-typeof": "warn",
+    ...disabledRules
+  },
+  settings: {
+    jsdoc: {
+      augmentsExtendsReplacesDocs: false,
+      exemptDestructuredRootsFromChecks: false,
+      ignoreInternal: false,
+      ignorePrivate: false,
+      ignoreReplacesDocs: true,
+      implementsReplacesDocs: false,
+      overrideReplacesDocs: true,
+      tagNamePreference: {}
+    },
+    "jsx-a11y": {
+      attributes: {},
+      components: {},
+      polymorphicPropName: null
+    },
+    next: {
+      rootDir: []
+    },
+    react: {
+      formComponents: [],
+      linkComponents: []
+    },
+    vitest: {
+      typecheck: false
     }
   }
+};
+
+// src/eslint/globs.ts
+var GLOB_TS = "**/*.?([cm])ts";
+var GLOB_TSX = "**/*.?([cm])tsx";
+var GLOB_EXCLUDE = [
+  "**/node_modules",
+  "**/dist",
+  "**/package-lock.json",
+  "**/yarn.lock",
+  "**/pnpm-lock.yaml",
+  "**/bun.lockb",
+  "**/generated/**",
+  "**/output",
+  "**/coverage",
+  "**/temp",
+  "**/.temp",
+  "**/tmp",
+  "**/build",
+  "**/.tmp",
+  "**/.history",
+  "**/.vitepress/cache",
+  "**/.nuxt",
+  "**/.turbo/**",
+  "**/playwright-report-html/**",
+  "**/playwright-report-allure/**",
+  "**/playwright-report-*/**",
+  "**/.git/**",
+  "**/.next",
+  "**/out/**",
+  "**/storybook-static/**",
+  "**/.svelte-kit",
+  "**/.vercel",
+  "**/.changeset",
+  "**/.idea",
+  "**/.cache",
+  "**/.output",
+  "**/.vite-inspect",
+  "**/.yarn",
+  "**/vite.config.*.timestamp-*",
+  "**/CHANGELOG*.md",
+  "**/*.min.*",
+  "**/LICENSE*",
+  "**/__snapshots__",
+  "**/auto-import?(s).d.ts",
+  "**/components.d.ts"
 ];
-var defineConfig = async (config, options = {
-  plugins: {
-    compat: { disabled: true },
-    perfectionist: { disabled: true },
-    vitest: { disabled: true },
-    yaml: { disabled: true }
-  }
-}) => {
-  const arguments_ = [
-    globalIgnores(
-      options?.globalIgnores || [
-        "**/.next/**",
-        "**/storybook-static/**",
-        "**/.git/**",
-        "**/.turbo/**",
-        "**/out/**",
-        "**/generated/**",
-        "**/playwright-report-html/**",
-        "**/playwright-report-allure/**",
-        "**/dist",
-        "**/build",
-        "**/node_modules"
-      ]
-    ),
-    eslint.configs.recommended,
-    tseslint.configs.recommended,
-    {
-      rules: {
-        "@typescript-eslint/consistent-type-imports": [
+
+// src/eslint/plugins/arrayFunc.ts
+async function arrayFunc() {
+  const plugin = await import("eslint-plugin-array-func");
+  return [
+    {
+      name: "shibanet0/array-func/rules",
+      plugins: {
+        "array-func": plugin.default
+      },
+      rules: {
+        ...plugin.default.configs.recommended.rules
+      }
+    },
+    {
+      rules: {
+        "array-func/from-map": "off",
+        "array-func/prefer-array-from": "off"
+      }
+    }
+  ];
+}
+
+// src/eslint/plugins/deMorgan.ts
+async function deMorgan() {
+  const plugin = await import("eslint-plugin-de-morgan");
+  return [
+    {
+      name: "shibanet0/de-morgan/rules",
+      plugins: {
+        "de-morgan": plugin.default
+      },
+      rules: {
+        ...plugin.default.configs.recommended.rules
+      }
+    }
+  ];
+}
+
+// src/eslint/plugins/import.ts
+async function pluginImport() {
+  const plugin = await import("eslint-plugin-import");
+  return [
+    {
+      name: "shibanet0/import/rules",
+      plugins: {
+        import: plugin.default
+      },
+      rules: {
+        ...plugin.flatConfigs.recommended.rules
+      }
+    },
+    {
+      rules: {
+        "import/default": "off",
+        "import/extensions": "off",
+        "import/named": "off",
+        "import/namespace": "off",
+        "import/no-extraneous-dependencies": "off",
+        "import/no-relative-packages": "off",
+        "import/no-unresolved": "off",
+        "import/order": "off",
+        "import/prefer-default-export": "off"
+      }
+    }
+  ];
+}
+
+// src/eslint/plugins/javascript.ts
+var javascript = async () => {
+  const [plugin, globals] = await Promise.all([import("@eslint/js"), import("globals")]);
+  return [
+    { ...plugin.default.configs.recommended, name: "shibanet0/js" },
+    {
+      languageOptions: {
+        ecmaVersion: "latest",
+        globals: {
+          ...globals.browser,
+          ...globals.es2026,
+          ...globals.node,
+          document: "readonly",
+          navigator: "readonly",
+          window: "readonly"
+        },
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true
+          },
+          ecmaVersion: "latest",
+          sourceType: "module"
+        },
+        sourceType: "module"
+      },
+      linterOptions: {
+        reportUnusedDisableDirectives: false
+      },
+      name: "shibanet0/js/setup"
+    },
+    { rules: { "no-empty": "off", "no-restricted-imports": "off", "no-undef": "off" } }
+  ];
+};
+
+// src/eslint/plugins/jsx-a11y.ts
+async function jsxA11y() {
+  const plugin = await import("eslint-plugin-jsx-a11y");
+  return [
+    {
+      name: "shibanet0/jsx-a11y/rules",
+      plugins: {
+        "jsx-a11y": plugin.default
+      },
+      rules: {
+        ...plugin.default.flatConfigs.recommended.rules
+      }
+    },
+    {
+      rules: {
+        "jsx-a11y/click-events-have-key-events": "off",
+        "jsx-a11y/interactive-supports-focus": "off",
+        "jsx-a11y/no-autofocus": "off",
+        "jsx-a11y/tabindex-no-positive": "off"
+      }
+    }
+  ];
+}
+
+// src/eslint/plugins/no-use-extend-native.ts
+async function noUseExtendNative() {
+  const plugin = await import("eslint-plugin-no-use-extend-native");
+  return [
+    {
+      name: "shibanet0/no-use-extend-native/rules",
+      plugins: {
+        "no-use-extend-native": plugin.default
+      },
+      rules: {
+        ...plugin.default.configs.recommended.rules
+      }
+    }
+  ];
+}
+
+// src/eslint/plugins/perfectionist.ts
+async function perfectionist() {
+  const plugin = await import("eslint-plugin-perfectionist");
+  return [
+    {
+      files: ["**/*.css.ts"],
+      name: "shibanet0/perfectionist/vanilla-extract/rules",
+      plugins: {
+        perfectionist: plugin.default
+      },
+      rules: {
+        "perfectionist/sort-objects": "off"
+      }
+    },
+    {
+      name: "shibanet0/perfectionist/rules",
+      plugins: {
+        perfectionist: plugin.default
+      },
+      rules: {
+        ...plugin.default.configs["recommended-natural"].rules,
+        "perfectionist/sort-imports": [
           "error",
           {
-            disallowTypeAnnotations: true,
-            fixStyle: "separate-type-imports",
-            prefer: "type-imports"
+            customGroups: [
+              {
+                elementNamePattern: ["^i18next$", "^i18next-.+"],
+                groupName: "i18next"
+              },
+              {
+                elementNamePattern: [
+                  "^react$",
+                  "^react-.+",
+                  "^@react-.+",
+                  "^swr$",
+                  "^next$",
+                  "^next/.+",
+                  "^next-.+",
+                  "^@next-.+"
+                ],
+                groupName: "react"
+              },
+              {
+                elementNamePattern: ["^antd$", "^@ant-design.+"],
+                groupName: "antd"
+              },
+              {
+                elementNamePattern: ["^fastify$", "^@fastify.+", "^@sinclair/typebox$"],
+                groupName: "fastify"
+              }
+              // {
+              //   elementNamePattern: [
+              //     String.raw`.+\.avif$`,
+              //     String.raw`.+\.webp$`,
+              //     String.raw`.+\.svg$`,
+              //     String.raw`.+\.png$`,
+              //     String.raw`.+\.jpg$`,
+              //     String.raw`.+\.jpeg$`,
+              //     String.raw`.+\.gif$`,
+              //   ],
+              //   groupName: "media/images",
+              // },
+            ],
+            groups: [
+              "i18next",
+              "react",
+              "antd",
+              "fastify",
+              // "media/images",
+              "type-import",
+              ["value-builtin", "value-external"],
+              "type-internal",
+              "value-internal",
+              ["type-parent", "type-sibling", "type-index"],
+              ["value-parent", "value-sibling", "value-index"],
+              "ts-equals-import",
+              "unknown"
+            ],
+            order: "asc",
+            type: "alphabetical"
+          }
+        ]
+      }
+    },
+    {
+      rules: {
+        // "perfectionist/sort-objects": "off",
+        // "perfectionist/sort-variable-declarations": "off",
+        // "perfectionist/sort-jsx-props": "off",
+        // "perfectionist/sort-modules": "off",
+        // "perfectionist/sort-classes": "off",
+        // "perfectionist/sort-enums": "off",
+      }
+    }
+  ];
+}
+
+// src/eslint/plugins/promise.ts
+async function promise() {
+  const plugin = await import("eslint-plugin-promise");
+  return [
+    {
+      name: "shibanet0/promise/rules",
+      plugins: {
+        promise: plugin.default
+      },
+      rules: {
+        ...plugin.default.configs["flat/recommended"].rules
+      }
+    },
+    {
+      rules: {
+        "promise/always-return": "off",
+        "promise/catch-or-return": "off",
+        "promise/no-nesting": "off"
+      }
+    }
+  ];
+}
+
+// src/eslint/plugins/react.ts
+async function react() {
+  const plugin = await import("eslint-plugin-react");
+  return [
+    {
+      name: "shibanet0/react/rules",
+      plugins: {
+        react: plugin.default
+      },
+      rules: {
+        ...plugin.default.configs["jsx-runtime"].rules,
+        ...plugin.default.configs.recommended.rules,
+        "react/destructuring-assignment": "off",
+        // TODO
+        "react/display-name": "off",
+        "react/forbid-component-props": "off",
+        // TODO
+        "react/forward-ref-uses-ref": "off",
+        "react/function-component-definition": "off",
+        "react/iframe-missing-sandbox": "off",
+        "react/jsx-child-element-spacing": "off",
+        "react/jsx-closing-tag-location": "off",
+        // TODO
+        "react/jsx-curly-newline": "off",
+        // TODO
+        "react/jsx-filename-extension": "off",
+        "react/jsx-handler-names": "off",
+        "react/jsx-indent": "off",
+        // TODO
+        // "react/jsx-max-depth": "off", // TODO
+        "react/jsx-max-props-per-line": "off",
+        // TODO
+        "react/jsx-newline": "off",
+        // TODO
+        "react/jsx-no-bind": "off",
+        // TODO
+        "react/jsx-no-literals": "off",
+        // TODO
+        "react/jsx-no-useless-fragment": "off",
+        "react/jsx-one-expression-per-line": "off",
+        // TODO
+        "react/jsx-pascal-case": "off",
+        "react/jsx-props-no-spreading": "off",
+        "react/jsx-sort-props": "off",
+        // TODO
+        "react/no-array-index-key": "off",
+        // TODO
+        "react/no-unknown-property": "off",
+        "react/no-unused-prop-types": "warn",
+        "react/prefer-read-only-props": "off",
+        // TODO
+        "react/prop-types": "off",
+        "react/react-in-jsx-scope": "off",
+        "react/require-default-props": "off"
+      }
+    }
+  ];
+}
+
+// src/eslint/plugins/react-hooks.ts
+async function reactHooks() {
+  const plugin = await import("eslint-plugin-react-hooks");
+  return [
+    {
+      name: "shibanet0/react-hooks/rules",
+      plugins: {
+        "react-hooks": plugin.default
+      },
+      rules: {
+        ...plugin.default.configs.flat["recommended-latest"].rules
+      }
+    }
+  ];
+}
+
+// src/eslint/plugins/react-perf.ts
+async function reactPerf() {
+  const plugin = await import("eslint-plugin-react-perf");
+  return [
+    {
+      name: "shibanet0/react-perf/rules",
+      plugins: {
+        "react-perf": plugin.default
+      },
+      rules: {
+        ...plugin.default.configs.flat.recommended.rules
+      }
+    }
+  ];
+}
+
+// src/eslint/plugins/react-prefer-function-component.ts
+async function reactPreferFunctionComponent() {
+  const plugin = await import("eslint-plugin-react-prefer-function-component");
+  const cfg = await import("eslint-plugin-react-prefer-function-component/config");
+  return [
+    {
+      name: "shibanet0/react-prefer-function-component/rules",
+      plugins: {
+        "react-prefer-function-component": plugin.default
+      },
+      rules: {
+        ...cfg.default.configs.recommended.rules
+      }
+    }
+  ];
+}
+
+// src/eslint/plugins/react-refresh.ts
+async function reactRefresh() {
+  const plugin = await import("eslint-plugin-react-refresh");
+  return [
+    {
+      name: "shibanet0/react-refresh/rules",
+      plugins: {
+        "react-refresh": plugin.default
+      },
+      rules: {
+        ...plugin.default.configs.recommended.rules
+      }
+    }
+  ];
+}
+
+// src/eslint/plugins/security.ts
+async function security() {
+  const plugin = await import("eslint-plugin-security");
+  return [
+    {
+      name: "shibanet0/security/rules",
+      plugins: {
+        security: plugin.default
+      },
+      rules: {
+        ...plugin.default.configs.recommended.rules
+      }
+    },
+    {
+      rules: {
+        "security/detect-non-literal-fs-filename": "off",
+        "security/detect-object-injection": "off"
+      }
+    }
+  ];
+}
+
+// src/eslint/plugins/sonarjs.ts
+async function sonarjs() {
+  const plugin = await import("eslint-plugin-sonarjs");
+  return [
+    {
+      name: "shibanet0/sonarjs/rules",
+      plugins: {
+        sonarjs: plugin.default
+      },
+      rules: {
+        ...plugin.default.configs.recommended.rules
+      }
+    },
+    {
+      rules: {
+        "sonarjs/class-name": "off",
+        "sonarjs/cognitive-complexity": "off",
+        "sonarjs/constructor-for-side-effects": "off",
+        "sonarjs/duplicates-in-character-class": "off",
+        "sonarjs/no-commented-code": "off",
+        "sonarjs/no-dead-store": "off",
+        "sonarjs/no-duplicate-string": "off",
+        "sonarjs/no-empty-test-file": "off",
+        "sonarjs/no-extra-arguments": "off",
+        "sonarjs/no-ignored-exceptions": "off",
+        "sonarjs/no-nested-conditional": "off",
+        "sonarjs/no-nested-functions": "off",
+        "sonarjs/no-nested-template-literals": "off",
+        "sonarjs/no-os-command-from-path": "off",
+        "sonarjs/no-small-switch": "off",
+        "sonarjs/os-command": "off",
+        "sonarjs/redundant-type-aliases": "off",
+        "sonarjs/slow-regex": "off",
+        "sonarjs/todo-tag": "off",
+        "sonarjs/unused-import": "off"
+      }
+    }
+  ];
+}
+
+// src/eslint/plugins/storybook.ts
+async function storybook() {
+  return [
+    // {
+    //   name: "shibanet0/storybook/rules",
+    //   plugins: {
+    //     storybook: plugin.default,
+    //   },
+    //   rules: {
+    //     ...plugin.default.configs["flat/recommended"].map(el=>el.rules),
+    //   },
+    // },
+  ];
+}
+
+// src/eslint/plugins/turbo.ts
+async function turbo() {
+  const plugin = await import("eslint-plugin-turbo");
+  return [
+    {
+      name: "shibanet0/turbo/rules",
+      plugins: {
+        turbo: plugin.default
+      },
+      rules: {
+        ...plugin.default.configs["flat/recommended"].rules
+      }
+    }
+  ];
+}
+
+// src/eslint/plugins/typescript.ts
+import { defineConfig } from "eslint/config";
+var typescript = async () => {
+  const plugin = await import("typescript-eslint");
+  return defineConfig({
+    extends: [...plugin.default.configs.recommended],
+    files: [GLOB_TS, GLOB_TSX],
+    name: "shibanet0/typescript",
+    rules: {
+      "@typescript-eslint/ban-ts-comment": "off",
+      "@typescript-eslint/consistent-type-imports": [
+        "error",
+        {
+          disallowTypeAnnotations: true,
+          fixStyle: "separate-type-imports",
+          prefer: "type-imports"
+        }
+      ],
+      "@typescript-eslint/no-dynamic-delete": "off",
+      "@typescript-eslint/no-empty-interface": "off",
+      "@typescript-eslint/no-empty-object-type": "off",
+      "@typescript-eslint/no-explicit-any": "off",
+      "@typescript-eslint/no-extraneous-class": "off",
+      "@typescript-eslint/no-invalid-void-type": "off",
+      "@typescript-eslint/no-require-imports": "off",
+      // "@typescript-eslint/no-explicit-any": "off",
+      "@typescript-eslint/no-unnecessary-type-constraint": "off",
+      "@typescript-eslint/no-unused-vars": "off",
+      // "@typescript-eslint/no-unused-vars": ["error", { argsIgnorePattern: "^_" }],
+      "@typescript-eslint/no-var-requires": "off",
+      "@typescript-eslint/triple-slash-reference": "off"
+    }
+  });
+};
+
+// src/eslint/plugins/unicorn.ts
+async function unicorn() {
+  const plugin = await import("eslint-plugin-unicorn");
+  return [
+    {
+      name: "shibanet0/unicorn/rules",
+      plugins: {
+        unicorn: plugin.default
+      },
+      rules: {
+        ...plugin.default.configs.recommended.rules
+      }
+    },
+    {
+      rules: {
+        "unicorn/catch-error-name": "off",
+        "unicorn/consistent-function-scoping": "off",
+        "unicorn/empty-brace-spaces": "off",
+        "unicorn/filename-case": "off",
+        "unicorn/import-style": "off",
+        "unicorn/no-abusive-eslint-disable": "off",
+        "unicorn/no-array-for-each": "off",
+        "unicorn/no-array-reduce": "off",
+        "unicorn/no-array-reverse": "off",
+        "unicorn/no-array-sort": "off",
+        "unicorn/no-empty-file": "off",
+        "unicorn/no-immediate-mutation": "off",
+        "unicorn/no-keyword-prefix": ["error", { disallowedPrefixes: ["new"] }],
+        "unicorn/no-lonely-if": "off",
+        "unicorn/no-negated-condition": "off",
+        "unicorn/no-nested-ternary": "off",
+        "unicorn/no-null": "off",
+        "unicorn/no-process-exit": "off",
+        "unicorn/no-single-promise-in-promise-methods": "off",
+        "unicorn/no-unreadable-iife": "off",
+        "unicorn/no-useless-collection-argument": "off",
+        "unicorn/no-useless-error-capture-stack-trace": "off",
+        "unicorn/prefer-add-event-listener": "off",
+        "unicorn/prefer-array-some": "off",
+        "unicorn/prefer-classlist-toggle": "off",
+        "unicorn/prefer-dom-node-append": "off",
+        "unicorn/prefer-dom-node-remove": "off",
+        "unicorn/prefer-dom-node-text-content": "off",
+        "unicorn/prefer-global-this": "off",
+        "unicorn/prefer-module": "off",
+        "unicorn/prefer-number-properties": "off",
+        "unicorn/prefer-optional-catch-binding": "off",
+        "unicorn/prefer-query-selector": "off",
+        "unicorn/prefer-set-has": "off",
+        "unicorn/prefer-single-call": "off",
+        "unicorn/prefer-spread": "off",
+        "unicorn/prefer-string-raw": "off",
+        "unicorn/prefer-type-error": "off",
+        "unicorn/prevent-abbreviations": "off",
+        "unicorn/require-module-specifiers": "off"
+      }
+    }
+  ];
+}
+
+// src/eslint/plugins/unused-imports.ts
+async function unusedImports() {
+  const plugin = await import("../dist-SV6KNVWH.js");
+  return [
+    {
+      name: "shibanet0/unused-imports/rules",
+      plugins: {
+        "unused-imports": plugin.default
+      },
+      rules: {
+        "no-unused-vars": "off",
+        // or "@typescript-eslint/no-unused-vars": "off",
+        "unused-imports/no-unused-imports": "error",
+        "unused-imports/no-unused-vars": [
+          "warn",
+          {
+            args: "after-used",
+            argsIgnorePattern: "^_",
+            vars: "all",
+            varsIgnorePattern: "^_"
           }
-        ],
-        "@typescript-eslint/no-empty-interface": "off",
-        "@typescript-eslint/no-empty-object-type": "off",
-        "@typescript-eslint/no-explicit-any": "off",
-        "@typescript-eslint/no-unnecessary-type-constraint": "off",
-        "@typescript-eslint/no-unused-vars": ["error", { argsIgnorePattern: "^_" }],
-        "@typescript-eslint/no-var-requires": "off"
+        ]
       }
     }
   ];
-  if (!options?.plugins?.["yaml"]?.disabled) {
-    const { yamlRules } = await import("../yaml-LUJQGNLH.js");
-    arguments_.push(yamlRules);
+}
+
+// src/eslint/index.ts
+import { globalIgnores as globalIgnores2 } from "@eslint/config-helpers";
+var todoEnable = [
+  {
+    rules: {}
+  },
+  {
+    linterOptions: {
+      reportUnusedDisableDirectives: "error"
+    }
+  }
+];
+var oxlintRules = oxlint.buildFromOxlintConfig(
+  oxlintConfig
+);
+var defaultOptions = {
+  plugins: {
+    turbo: { disabled: true }
+  }
+};
+var defineConfig2 = async (config, options) => {
+  const _options = {
+    ...defaultOptions,
+    ...options,
+    plugins: {
+      ...defaultOptions.plugins,
+      ...options?.plugins
+    }
+  };
+  const arguments_ = [];
+  if (!_options?.plugins?.["prettier"]?.disabled) {
+    const { prettierRules } = await import("../prettier-VWVEU6BH.js");
+    arguments_.push(prettierRules);
+  }
+  if (!_options?.plugins?.["playwright"]?.disabled) {
+    const { playwrightRules } = await import("../playwright-BGT6YZAD.js");
+    arguments_.push(playwrightRules);
+  }
+  if (!_options?.plugins?.["toml"]?.disabled) {
+    const { tomlRules } = await import("../toml-Y76F5J2F.js");
+    arguments_.push(...tomlRules);
+  }
+  if (!_options?.plugins?.["json"]?.disabled) {
+    const { jsonRules } = await import("../json-LWTL4ZNK.js");
+    arguments_.push(...jsonRules);
+  }
+  const configs = [
+    [Promise.resolve(globalIgnores(GLOB_EXCLUDE, "shibanet0/ignores"))],
+    javascript(),
+    typescript()
+  ];
+  if (!_options?.plugins?.["unicorn"]?.disabled) {
+    configs.push(unicorn());
+  }
+  if (!_options?.plugins?.["sonarjs"]?.disabled) {
+    configs.push(sonarjs());
+  }
+  if (!_options?.plugins?.["deMorgan"]?.disabled) {
+    configs.push(deMorgan());
+  }
+  if (!_options?.plugins?.["perfectionist"]?.disabled) {
+    configs.push(perfectionist());
+  }
+  if (!_options?.plugins?.["eslint-plugin-array-func"]?.disabled) {
+    configs.push(arrayFunc());
+  }
+  if (!_options?.plugins?.["unused-imports"]?.disabled) {
+    configs.push(unusedImports());
   }
-  if (!options?.plugins?.["perfectionist"]?.disabled) {
-    const { perfectionistRules } = await import("../perfectionist-YHPWKMW3.js");
-    arguments_.push(...perfectionistRules);
+  if (!_options?.plugins?.import?.disabled) {
+    configs.push(pluginImport());
   }
-  return eslintDefineConfig([...arguments_, ...config || [], ...todoDisable]);
+  if (!_options?.plugins?.promise?.disabled) {
+    configs.push(promise());
+  }
+  if (!_options?.plugins?.turbo?.disabled) {
+    configs.push(turbo());
+  }
+  if (!_options?.plugins?.["no-use-extend-native"]?.disabled) {
+    configs.push(noUseExtendNative());
+  }
+  if (!_options?.plugins?.["react-prefer-function-component"]?.disabled) {
+    configs.push(reactPreferFunctionComponent());
+  }
+  if (!_options?.plugins?.["security"]?.disabled) {
+    configs.push(security());
+  }
+  if (_options?.react) {
+    if (!_options?.plugins?.["react"]?.disabled) {
+      configs.push(react());
+    }
+    if (!_options?.plugins?.["jsx-a11y"]?.disabled) {
+      configs.push(jsxA11y());
+    }
+    if (!_options?.plugins?.["react-hooks"]?.disabled) {
+      configs.push(reactHooks());
+    }
+    if (!_options?.plugins?.["react-perf"]?.disabled) {
+      configs.push(reactPerf());
+    }
+    if (!_options?.plugins?.["storybook"]?.disabled) {
+      configs.push(storybook());
+    }
+    if (!_options?.plugins?.["react-refresh"]?.disabled) {
+      configs.push(reactRefresh());
+    }
+  }
+  const resolved = await Promise.all(configs).then((r) => r.flat());
+  eslintDefineConfig([
+    ...arguments_,
+    ...config || [],
+    {
+      rules: {}
+    },
+    {
+      rules: {
+        "no-restricted-imports": [
+          "warn",
+          {
+            paths: [
+              { message: "Use 'swiper' instead", name: "react-swipeable-views" },
+              { message: "Use '@vanilla-extract/css' instead", name: "styled-components" },
+              { message: "Use 'antd/es/*' instead", name: "antd" },
+              { message: "Use 'components/Datepicker' instead", name: "antd/es/date-picker" },
+              { message: "Use 'antd/es/*' instead", name: "antd/lib" },
+              { message: "Use 'antd/es/*' instead", name: "antd/dist" },
+              { message: "Use 'date-fns/*' instead", name: "date-fns" },
+              { name: "mobx" },
+              { name: "moment" },
+              { name: "axios" },
+              { name: "mobx-utils" },
+              { name: "mobx-react-lite" }
+            ]
+          }
+        ]
+      }
+    },
+    {
+      rules: {
+        "typescript-eslint/no-extraneous-class": "off",
+        "unused-imports/no-unused-vars": "off",
+        "vanilla-extract/no-empty-style-blocks": "off"
+      }
+    },
+    ...oxlintRules,
+    ...todoEnable
+  ]);
+  const composer = new FlatConfigComposer();
+  composer.append(...resolved);
+  composer.append(...config || []);
+  return composer;
+  return eslintDefineConfig([
+    ...resolved.map((el) => ({
+      files: ["**/*.ts"],
+      ...el
+    })),
+    ...oxlintRules,
+    ...todoEnable
+  ]);
 };
 export {
-  defineConfig
+  defineConfig2 as defineConfig,
+  globalIgnores2 as globalIgnores
 };