1441 lines
45 KiB
JavaScript
1441 lines
45 KiB
JavaScript
import { composer, concat } from "eslint-flat-config-utils";
|
|
import { existsSync } from "node:fs";
|
|
import { relative, resolve } from "node:path";
|
|
import { confirm, outro, spinner } from "@clack/prompts";
|
|
import { createResolver } from "exsolve";
|
|
import { blue, underline } from "kolorist";
|
|
import { isPackageExists } from "local-pkg";
|
|
import { addDevDependency } from "nypm";
|
|
import { detect } from "package-manager-detector";
|
|
import { FlatCompat } from "@eslint/eslintrc";
|
|
import gitignoreConfig from "eslint-config-flat-gitignore";
|
|
import perfectionistPlugin from "eslint-plugin-perfectionist";
|
|
import { plugin as pnpmPlugin } from "eslint-plugin-pnpm";
|
|
import tseslintVendor from "typescript-eslint";
|
|
import unicornVendor from "eslint-plugin-unicorn";
|
|
import vueVendor from "eslint-plugin-vue";
|
|
import * as vueParser from "vue-eslint-parser";
|
|
import * as jsoncParser from "jsonc-eslint-parser";
|
|
import * as yamlParser from "yaml-eslint-parser";
|
|
import "@typescript-eslint/parser";
|
|
import { globalIgnores } from "eslint/config";
|
|
import eslint from "@eslint/js";
|
|
import globals from "globals";
|
|
//#region src/utils/autoimports.ts
|
|
const compat = new FlatCompat({});
|
|
const DEFAULT_AUTO_IMPORTS_PATH = ".eslintrc-auto-import";
|
|
const { resolveModulePath: resolveModulePath$1 } = createResolver({ extensions: [".json"] });
|
|
function loadAutoImports(options = true) {
|
|
if (!options) return {};
|
|
if (typeof options === "object" && typeof options.src === "object") return { languageOptions: options.src };
|
|
const autoImportsFile = typeof options === "object" && typeof options.src === "string" ? options.src : DEFAULT_AUTO_IMPORTS_PATH;
|
|
try {
|
|
const autoImportModuleURL = resolveModulePath$1(resolve(".", autoImportsFile), { try: true });
|
|
if (!autoImportModuleURL) return {};
|
|
return compat.extends(autoImportModuleURL)[0] ?? {};
|
|
} catch {
|
|
return {};
|
|
}
|
|
}
|
|
//#endregion
|
|
//#region src/utils/index.ts
|
|
const hasVuetifyConfig = hasPackage("eslint-config-vuetify");
|
|
async function interopDefault(m) {
|
|
const awaited = await m;
|
|
return awaited.default ?? awaited;
|
|
}
|
|
function isInEditorEnv() {
|
|
if (process.env.CI) return false;
|
|
if (isInGitHooksOrLintStaged()) return false;
|
|
return !!(process.env.VSCODE_PID || process.env.VSCODE_CWD || process.env.JETBRAINS_IDE || process.env.VIM || process.env.NVIM);
|
|
}
|
|
function isInGitHooksOrLintStaged() {
|
|
return !!(process.env.GIT_PARAMS || process.env.VSCODE_GIT_COMMAND || process.env.npm_lifecycle_script?.startsWith("lint-staged"));
|
|
}
|
|
function hasPackage(pkg, scope) {
|
|
return isPackageExists(pkg, { paths: scope ? [scope] : [] });
|
|
}
|
|
const currentScope = new URL(".", import.meta.url).pathname;
|
|
const currentRoot = process.cwd();
|
|
async function assertPackage(pkg, setting) {
|
|
if (!hasPackage(pkg, currentScope)) {
|
|
if (process.env.CI || process.stdout.isTTY === false || !hasVuetifyConfig) return;
|
|
if (await confirm({ message: `Package ${pkg} is required for this config but not installed. Do you want to install it?` }) === true) {
|
|
const s = spinner();
|
|
s.start(`Installing ${pkg}`);
|
|
await addDevDependency(pkg);
|
|
s.stop(`Installed ${pkg}`);
|
|
outro("Please, rerun the command or reopen your editor to apply the changes");
|
|
} else {
|
|
const { ESLint } = await import("eslint");
|
|
const config = await new ESLint({}).findConfigFile();
|
|
const configMessage = config ? `${underline(relative(currentRoot, config))}` : "config file";
|
|
if (setting) outro(`Please, install the package or set ${blue(setting)} in your ${configMessage}`);
|
|
else outro(`Please, install the package or disable the setting in your ${configMessage} file`);
|
|
process.exit(1);
|
|
}
|
|
}
|
|
}
|
|
function hasFile(file) {
|
|
return existsSync(resolve(process.cwd(), file));
|
|
}
|
|
async function getPackageManager() {
|
|
return detect({ cwd: process.cwd() });
|
|
}
|
|
const { resolveModulePath } = createResolver({ extensions: [
|
|
".js",
|
|
".mjs",
|
|
".cjs",
|
|
".ts",
|
|
".mts",
|
|
".cts"
|
|
] });
|
|
resolveModulePath("./eslint.config", { try: true });
|
|
//#endregion
|
|
//#region src/configs/antfu.ts
|
|
async function antfu(options = true) {
|
|
const filesConfig = typeof options === "boolean" || !options.files ? {} : { files: options.files };
|
|
const antfuPlugin = await interopDefault(import("eslint-plugin-antfu"));
|
|
return [{
|
|
name: "vuetify/antfu",
|
|
...filesConfig,
|
|
plugins: { antfu: antfuPlugin },
|
|
rules: {
|
|
"antfu/import-dedupe": "error",
|
|
"antfu/top-level-function": "error",
|
|
"antfu/no-import-node-modules-by-path": "error",
|
|
"antfu/consistent-chaining": "error"
|
|
}
|
|
}];
|
|
}
|
|
//#endregion
|
|
//#region src/globs.ts
|
|
const GLOB_SRC_EXT = "?([cm])[jt]s?(x)";
|
|
const GLOB_JS = "**/*.?([cm])js";
|
|
const GLOB_JSX = "**/*.?([cm])jsx";
|
|
const GLOB_TS = "**/*.?([cm])ts";
|
|
const GLOB_TSX = "**/*.?([cm])tsx";
|
|
const GLOB_VUE = "**/*.vue";
|
|
const GLOB_TESTS = [
|
|
`**/__tests__/**/*.${GLOB_SRC_EXT}`,
|
|
`**/*.spec.${GLOB_SRC_EXT}`,
|
|
`**/*.test.${GLOB_SRC_EXT}`,
|
|
`**/*.bench.${GLOB_SRC_EXT}`,
|
|
`**/*.benchmark.${GLOB_SRC_EXT}`
|
|
];
|
|
const GLOB_EXCLUDE = [
|
|
"**/node_modules",
|
|
"**/dist",
|
|
"**/package-lock.json",
|
|
"**/yarn.lock",
|
|
"**/pnpm-lock.yaml",
|
|
"**/bun.lockb",
|
|
"**/output",
|
|
"**/coverage",
|
|
"**/temp",
|
|
"**/.temp",
|
|
"**/tmp",
|
|
"**/.tmp",
|
|
"**/.history",
|
|
"**/.vitepress/cache",
|
|
"**/.nuxt",
|
|
"**/.vercel",
|
|
"**/.changeset",
|
|
"**/.idea",
|
|
"**/.cache",
|
|
"**/.output",
|
|
"**/.vite-inspect",
|
|
"**/.yarn",
|
|
"**/vite.config.*.timestamp-*",
|
|
"**/CHANGELOG*.md",
|
|
"**/*.min.*",
|
|
"**/LICENSE*",
|
|
"**/__snapshots__",
|
|
"**/auto-import?(s).d.ts",
|
|
"**/components.d.ts"
|
|
];
|
|
//#endregion
|
|
//#region src/configs/autoimports.ts
|
|
function autoimports(options = true) {
|
|
const autoimports = loadAutoImports(options);
|
|
return {
|
|
name: "vuetfiy/autoimports",
|
|
files: [
|
|
GLOB_JS,
|
|
GLOB_TS,
|
|
GLOB_JSX,
|
|
GLOB_TSX
|
|
],
|
|
...autoimports
|
|
};
|
|
}
|
|
//#endregion
|
|
//#region src/configs/gitignore.ts
|
|
const DEFAULT_OPTIONS = {
|
|
sources: [".gitignore"],
|
|
gitmodules: []
|
|
};
|
|
function gitignore(options = true) {
|
|
if (!options) return {};
|
|
if (typeof options === "boolean") options = DEFAULT_OPTIONS;
|
|
return gitignoreConfig({
|
|
files: options?.sources,
|
|
filesGitModules: options?.gitmodules,
|
|
name: "vuetify/gitignore"
|
|
});
|
|
}
|
|
//#endregion
|
|
//#region src/configs/ignore.ts
|
|
function ignore(options) {
|
|
if (!options) return {};
|
|
if (typeof options === "boolean") options = { ignore: GLOB_EXCLUDE };
|
|
const ignoreList = options?.ignore ?? GLOB_EXCLUDE;
|
|
const extendIgnoreList = options?.extendIgnore ?? [];
|
|
return globalIgnores([...ignoreList, ...extendIgnoreList], "vuetify/ignore");
|
|
}
|
|
//#endregion
|
|
//#region src/configs/imports.ts
|
|
async function imports(options = true) {
|
|
const filesConfig = typeof options === "boolean" || !options?.files ? {} : { files: options.files };
|
|
const pluginType = typeof options === "boolean" || !options?.plugin ? "import-lite" : options.plugin;
|
|
let selectedPlugin;
|
|
if (pluginType === "import-x") {
|
|
await assertPackage("eslint-plugin-import-x", "import: { plugin: \"import-lite\" }");
|
|
selectedPlugin = (await import("eslint-plugin-import-x")).default;
|
|
} else selectedPlugin = (await import("eslint-plugin-import-lite")).default;
|
|
return [{
|
|
name: "vuetify/imports",
|
|
...filesConfig,
|
|
plugins: { import: selectedPlugin },
|
|
rules: {
|
|
"import/first": "error",
|
|
"import/no-duplicates": ["error", { "prefer-inline": false }],
|
|
"import/no-mutable-exports": "error",
|
|
"import/no-named-default": "error"
|
|
}
|
|
}];
|
|
}
|
|
//#endregion
|
|
//#region src/configs/js.ts
|
|
function js(options = true) {
|
|
const files = typeof options === "boolean" ? [
|
|
GLOB_JS,
|
|
GLOB_TS,
|
|
GLOB_JSX,
|
|
GLOB_TSX
|
|
] : options.files;
|
|
return [{
|
|
files,
|
|
...eslint.configs.recommended,
|
|
name: "vuetify/js/recommended"
|
|
}, {
|
|
files,
|
|
name: "vuetify/js",
|
|
languageOptions: {
|
|
globals: {
|
|
...globals.node,
|
|
...globals.es2021,
|
|
...globals.browser
|
|
},
|
|
parserOptions: {
|
|
ecmaFeatures: { jsx: true },
|
|
sourceType: "module"
|
|
},
|
|
sourceType: "module"
|
|
},
|
|
rules: {
|
|
"complexity": ["error", 32],
|
|
"curly": ["error", "all"],
|
|
"no-case-declarations": "off",
|
|
"no-debugger": process.env.NODE_ENV === "production" ? "error" : "off",
|
|
"no-empty": "error",
|
|
"no-prototype-builtins": "off",
|
|
"no-return-assign": "off",
|
|
"no-unused-vars": "error",
|
|
"no-var": "error",
|
|
"no-void": "off",
|
|
"object-shorthand": ["error", "always"],
|
|
"prefer-const": ["error", {
|
|
destructuring: "all",
|
|
ignoreReadBeforeAssign: true
|
|
}]
|
|
}
|
|
}];
|
|
}
|
|
//#endregion
|
|
//#region src/configs/perfectionist.ts
|
|
function perfectionist(options = true) {
|
|
const filesConfig = typeof options === "boolean" || !options.files ? {} : { files: options.files };
|
|
const importRules = options === true || options && options?.import !== false;
|
|
const exportRules = options === true || options && options?.export !== false;
|
|
if (!importRules && !exportRules) return [];
|
|
const rules = {};
|
|
if (importRules) {
|
|
rules["perfectionist/sort-imports"] = ["error", {
|
|
groups: [
|
|
"type",
|
|
[
|
|
"type-parent",
|
|
"type-sibling",
|
|
"type-index",
|
|
"type-internal"
|
|
],
|
|
"builtin",
|
|
"external",
|
|
"internal",
|
|
[
|
|
"parent",
|
|
"sibling",
|
|
"index"
|
|
],
|
|
"side-effect",
|
|
"unknown"
|
|
],
|
|
newlinesBetween: "ignore",
|
|
order: "asc",
|
|
type: "natural"
|
|
}];
|
|
rules["perfectionist/sort-named-imports"] = ["error", {
|
|
order: "asc",
|
|
type: "natural"
|
|
}];
|
|
}
|
|
if (exportRules) {
|
|
rules["perfectionist/sort-exports"] = ["error", {
|
|
order: "asc",
|
|
type: "natural"
|
|
}];
|
|
rules["perfectionist/sort-named-exports"] = ["error", {
|
|
order: "asc",
|
|
type: "natural"
|
|
}];
|
|
}
|
|
return [{
|
|
name: "vuetify/perfectionist",
|
|
...filesConfig,
|
|
plugins: { perfectionist: perfectionistPlugin },
|
|
rules
|
|
}];
|
|
}
|
|
//#endregion
|
|
//#region src/configs/pnpm.ts
|
|
const hasWorkspace = hasFile("pnpm-workspace.yaml");
|
|
function pnpm(options = true) {
|
|
const enforceCatalog = typeof options === "object" ? options.enforceCatalog ?? false : false;
|
|
return [{
|
|
ignores: ["**/node_modules/**", "**/dist/**"],
|
|
files: typeof options === "object" && options.files ? options.files : ["package.json", "**/package.json"],
|
|
languageOptions: { parser: jsoncParser },
|
|
name: "vuetify/pnpm/package-json",
|
|
plugins: { pnpm: pnpmPlugin },
|
|
rules: {
|
|
"pnpm/json-prefer-workspace-settings": hasWorkspace ? "error" : "off",
|
|
"pnpm/json-enforce-catalog": enforceCatalog ? "error" : "off",
|
|
"pnpm/json-valid-catalog": enforceCatalog ? "error" : "off"
|
|
}
|
|
}, {
|
|
files: ["pnpm-workspace.yaml"],
|
|
languageOptions: { parser: yamlParser },
|
|
name: "vuetify/pnpm/pnpm-workspace-yaml",
|
|
plugins: { pnpm: pnpmPlugin },
|
|
rules: {
|
|
"pnpm/yaml-no-duplicate-catalog-item": "error",
|
|
"pnpm/yaml-no-unused-catalog-item": "error"
|
|
}
|
|
}];
|
|
}
|
|
//#endregion
|
|
//#region src/configs/stylistic.ts
|
|
async function stylistic(options = true, optionsVue = false) {
|
|
if (!options) return [];
|
|
const severity = options === true || !options?.severity ? "error" : options.severity;
|
|
const stylisticPlugin = await interopDefault(import("@stylistic/eslint-plugin"));
|
|
const stylistic = [{
|
|
name: "vuetify/stylistic",
|
|
plugins: { "@stylistic": stylisticPlugin },
|
|
rules: {
|
|
...stylisticPlugin.configs.customize({
|
|
indent: 2,
|
|
jsx: true,
|
|
quotes: "single",
|
|
semi: false,
|
|
severity
|
|
}).rules,
|
|
"@stylistic/space-before-function-paren": [severity, {
|
|
anonymous: "always",
|
|
asyncArrow: "always",
|
|
named: "always"
|
|
}],
|
|
"@stylistic/brace-style": [severity, "1tbs"],
|
|
"@stylistic/arrow-parens": [severity, "as-needed"]
|
|
}
|
|
}];
|
|
if (optionsVue) stylistic.push({
|
|
files: [GLOB_VUE],
|
|
name: "vuetify/stylistic/vue",
|
|
rules: { "@stylistic/indent": ["off"] }
|
|
});
|
|
return stylistic;
|
|
}
|
|
//#endregion
|
|
//#region src/configs/test.ts
|
|
async function test(options = true) {
|
|
if (!options) return {};
|
|
else if (options === true) if (!hasPackage("@vitest/eslint-plugin") && !hasPackage("eslint-plugin-jest")) return {};
|
|
else options = {
|
|
files: GLOB_TESTS,
|
|
runner: hasPackage("@vitest/eslint-plugin") ? "vitest" : "jest"
|
|
};
|
|
const files = options?.files ?? GLOB_TESTS;
|
|
const runner = options?.runner;
|
|
if (runner === "vitest") {
|
|
await assertPackage("@vitest/eslint-plugin", "test: false");
|
|
const vitestVendor = await interopDefault(import("@vitest/eslint-plugin"));
|
|
return [{
|
|
files,
|
|
plugins: {
|
|
"vitest": vitestVendor,
|
|
"no-only-tests": await interopDefault(import("eslint-plugin-no-only-tests"))
|
|
},
|
|
rules: {
|
|
...vitestVendor.configs.recommended.rules,
|
|
"no-only-tests/no-only-tests": "error"
|
|
}
|
|
}];
|
|
}
|
|
if (runner === "jest") {
|
|
await assertPackage("eslint-plugin-jest", "test: false");
|
|
const jestVendor = await interopDefault(import("eslint-plugin-jest"));
|
|
return [{
|
|
files,
|
|
plugins: {
|
|
"jest": jestVendor,
|
|
"no-only-tests": await interopDefault(import("eslint-plugin-no-only-tests"))
|
|
},
|
|
languageOptions: { globals: jestVendor.environments.globals.globals },
|
|
rules: {
|
|
"jest/no-disabled-tests": "warn",
|
|
"jest/no-focused-tests": "error",
|
|
"jest/no-identical-title": "error",
|
|
"jest/prefer-to-have-length": "warn",
|
|
"jest/valid-expect": "error",
|
|
"no-only-tests/no-only-tests": "error"
|
|
}
|
|
}];
|
|
}
|
|
return {};
|
|
}
|
|
//#endregion
|
|
//#region src/configs/ts.ts
|
|
function typescriptCore(preset) {
|
|
return tseslintVendor.config({
|
|
extends: [...tseslintVendor.configs[preset]],
|
|
files: [GLOB_TS, GLOB_TSX],
|
|
name: "vuetify/typescript",
|
|
rules: {
|
|
"@typescript-eslint/ban-ts-comment": "off",
|
|
"@typescript-eslint/member-ordering": "error",
|
|
"@typescript-eslint/no-inferrable-types": "error",
|
|
"@typescript-eslint/unified-signatures": "error",
|
|
"@typescript-eslint/no-invalid-this": "error",
|
|
"@typescript-eslint/consistent-type-imports": ["error", {
|
|
prefer: "type-imports",
|
|
fixStyle: "separate-type-imports"
|
|
}],
|
|
"@typescript-eslint/method-signature-style": ["error", "property"],
|
|
"@typescript-eslint/no-empty-object-type": "off",
|
|
"@typescript-eslint/no-explicit-any": "off",
|
|
"@typescript-eslint/no-import-type-side-effects": "error",
|
|
"@typescript-eslint/no-non-null-assertion": "off",
|
|
"@typescript-eslint/no-redeclare": "error",
|
|
"@typescript-eslint/no-unsafe-function-type": "off",
|
|
"@typescript-eslint/no-unused-expressions": ["error", {
|
|
allowShortCircuit: true,
|
|
allowTaggedTemplates: true,
|
|
allowTernary: true
|
|
}],
|
|
"@typescript-eslint/prefer-as-const": "warn",
|
|
"@typescript-eslint/prefer-literal-enum-member": ["error", { allowBitwiseExpressions: true }],
|
|
"no-unused-vars": "off",
|
|
"no-unused-expressions": "off",
|
|
"no-restricted-syntax": ["error", "TSEnumDeclaration[const=true]"],
|
|
"no-dupe-class-members": "off",
|
|
"no-redeclare": "off",
|
|
"no-use-before-define": "off",
|
|
"no-useless-constructor": "off",
|
|
"@typescript-eslint/no-empty-function": "off",
|
|
"@typescript-eslint/no-var-requires": "off",
|
|
"@typescript-eslint/no-unused-vars": ["warn", {
|
|
varsIgnorePattern: "^_",
|
|
argsIgnorePattern: "^_"
|
|
}]
|
|
}
|
|
});
|
|
}
|
|
function typescript(options = true) {
|
|
if (!options) return [];
|
|
const preset = options === true || !options?.preset ? "recommended" : options.preset;
|
|
const projectService = typeof options === "object" && options?.projectService || [
|
|
"recommendedTypeChecked",
|
|
"strictTypeChecked",
|
|
"all"
|
|
].includes(preset);
|
|
const tsconfigRootDir = typeof options === "object" ? options?.tsconfigRootDir : void 0;
|
|
return [
|
|
...typescriptCore(preset),
|
|
{ languageOptions: { parserOptions: {
|
|
projectService,
|
|
tsconfigRootDir
|
|
} } },
|
|
{
|
|
files: ["**/*.d.ts"],
|
|
name: "vuetify/typescript/dts",
|
|
rules: {
|
|
"eslint-comments/no-unlimited-disable": "off",
|
|
"import/no-duplicates": "off",
|
|
"no-restricted-syntax": "off",
|
|
"unused-imports/no-unused-vars": "off"
|
|
}
|
|
},
|
|
{
|
|
files: [GLOB_JS, "**/*.cjs"],
|
|
name: "vuetify/typescript/cjs-rules",
|
|
rules: { "@typescript-eslint/no-require-imports": "off" }
|
|
}
|
|
];
|
|
}
|
|
//#endregion
|
|
//#region src/configs/unicorn.ts
|
|
function unicorn(options = true) {
|
|
const filesConfig = typeof options === "boolean" || !options.files ? {} : { files: options.files };
|
|
return [{
|
|
...filesConfig,
|
|
...unicornVendor.configs["recommended"],
|
|
name: "vuetify/unicorn/recommended"
|
|
}, {
|
|
...filesConfig,
|
|
name: "vuetify/unicorn",
|
|
rules: {
|
|
"unicorn/filename-case": "off",
|
|
"unicorn/no-null": "off",
|
|
"unicorn/number-literal-case": "off",
|
|
"unicorn/template-indent": "off",
|
|
"unicorn/prevent-abbreviations": "off",
|
|
"unicorn/prefer-top-level-await": "off",
|
|
"unicorn/prefer-spread": "off",
|
|
"unicorn/no-await-expression-member": "off",
|
|
"unicorn/no-useless-undefined": "off",
|
|
"unicorn/no-array-reduce": "off",
|
|
"unicorn/no-array-push-push": "off",
|
|
"unicorn/prefer-string-replace-all": "off",
|
|
"unicorn/no-abusive-eslint-disable": "off",
|
|
"unicorn/import-style": "off",
|
|
"unicorn/prefer-module": "off",
|
|
"unicorn/consistent-function-scoping": "off",
|
|
"unicorn/prefer-global-this": "off"
|
|
}
|
|
}];
|
|
}
|
|
//#endregion
|
|
//#region src/configs/vue.ts
|
|
function vueTs(preset) {
|
|
return typescriptCore(preset).filter((config) => config.name !== "typescript-eslint/base").map((config) => {
|
|
return {
|
|
...config,
|
|
files: [GLOB_VUE],
|
|
name: `vuetify/vue/${config.name?.replace("vuetify/", "") || "anonymous"}`
|
|
};
|
|
});
|
|
}
|
|
const rules = {
|
|
...vueVendor.configs["flat/recommended"].map((c) => c.rules).reduce((acc, c) => ({
|
|
...acc,
|
|
...c
|
|
}), {}),
|
|
"vue/html-closing-bracket-newline": ["error", {
|
|
singleline: "never",
|
|
multiline: "always"
|
|
}],
|
|
"vue/html-closing-bracket-spacing": "error",
|
|
"vue/max-attributes-per-line": ["error", {
|
|
singleline: 4,
|
|
multiline: 1
|
|
}],
|
|
"vue/multi-word-component-names": "off",
|
|
"vue/multiline-html-element-content-newline": "off",
|
|
"vue/no-v-html": "off",
|
|
"vue/padding-line-between-tags": ["error", [{
|
|
blankLine: "always",
|
|
prev: "*:multi-line",
|
|
next: "*"
|
|
}, {
|
|
blankLine: "always",
|
|
prev: "*",
|
|
next: "*:multi-line"
|
|
}]],
|
|
"vue/script-indent": [
|
|
"error",
|
|
2,
|
|
{
|
|
baseIndent: 1,
|
|
switchCase: 1,
|
|
ignores: []
|
|
}
|
|
],
|
|
"vue/singleline-html-element-content-newline": "off",
|
|
"vue/valid-v-on": "off",
|
|
"vue/valid-v-slot": ["error", { allowModifiers: true }]
|
|
};
|
|
async function vue(options = true, tsOptions = true) {
|
|
const plugins = { vue: vueVendor };
|
|
const tsEnabled = !!tsOptions;
|
|
const tsPreset = typeof tsOptions === "boolean" ? "recommended" : tsOptions.preset || "recommended";
|
|
let a11config = [];
|
|
const tsConfig = tsEnabled ? vueTs(tsPreset) : [];
|
|
const languageOptions = {
|
|
parser: vueParser,
|
|
parserOptions: {
|
|
ecmaFeatures: { jsx: true },
|
|
extraFileExtensions: [".vue"],
|
|
sourceType: "module",
|
|
parser: tseslintVendor.parser
|
|
}
|
|
};
|
|
if (tsEnabled) plugins["@typescript-eslint"] = tseslintVendor.plugin;
|
|
if (typeof options === "object" && options?.a11y) {
|
|
await assertPackage("eslint-plugin-vuejs-accessibility", "vue.a11y: false");
|
|
a11config = (await interopDefault(import("eslint-plugin-vuejs-accessibility"))).configs["flat/recommended"];
|
|
}
|
|
return [
|
|
...a11config,
|
|
...tsConfig,
|
|
{
|
|
files: [GLOB_VUE],
|
|
languageOptions,
|
|
name: "vuetify/vue",
|
|
plugins,
|
|
processor: vueVendor.processors[".vue"],
|
|
rules: {
|
|
...rules,
|
|
"vue/block-lang": tsEnabled ? "off" : ["error", { script: { lang: "ts" } }]
|
|
}
|
|
},
|
|
{
|
|
name: "vuetify/vue/jsx",
|
|
files: [
|
|
GLOB_VUE,
|
|
GLOB_TSX,
|
|
GLOB_JSX
|
|
],
|
|
languageOptions,
|
|
plugins,
|
|
processor: vueVendor.processors[".vue"],
|
|
rules: {
|
|
"vue/attributes-order": ["error", { alphabetical: true }],
|
|
"vue/custom-event-name-casing": [
|
|
"error",
|
|
"kebab-case",
|
|
{ ignores: ["/^[a-z]+(?:-[a-z]+)*:[a-z]+(?:-[a-z]+)*$/u"] }
|
|
],
|
|
"vue/one-component-per-file": "off",
|
|
"vue/require-default-prop": "off",
|
|
"vue/require-prop-types": "off"
|
|
}
|
|
}
|
|
];
|
|
}
|
|
//#endregion
|
|
//#region node_modules/.pnpm/valibot@1.3.1_typescript@6.0.3/node_modules/valibot/dist/index.mjs
|
|
let store$4;
|
|
/**
|
|
* Returns the global configuration.
|
|
*
|
|
* @param config The config to merge.
|
|
*
|
|
* @returns The configuration.
|
|
*/
|
|
/* @__NO_SIDE_EFFECTS__ */
|
|
function getGlobalConfig(config$1) {
|
|
return {
|
|
lang: config$1?.lang ?? store$4?.lang,
|
|
message: config$1?.message,
|
|
abortEarly: config$1?.abortEarly ?? store$4?.abortEarly,
|
|
abortPipeEarly: config$1?.abortPipeEarly ?? store$4?.abortPipeEarly
|
|
};
|
|
}
|
|
let store$3;
|
|
/**
|
|
* Returns a global error message.
|
|
*
|
|
* @param lang The language of the message.
|
|
*
|
|
* @returns The error message.
|
|
*/
|
|
/* @__NO_SIDE_EFFECTS__ */
|
|
function getGlobalMessage(lang) {
|
|
return store$3?.get(lang);
|
|
}
|
|
let store$2;
|
|
/**
|
|
* Returns a schema error message.
|
|
*
|
|
* @param lang The language of the message.
|
|
*
|
|
* @returns The error message.
|
|
*/
|
|
/* @__NO_SIDE_EFFECTS__ */
|
|
function getSchemaMessage(lang) {
|
|
return store$2?.get(lang);
|
|
}
|
|
let store$1;
|
|
/**
|
|
* Returns a specific error message.
|
|
*
|
|
* @param reference The identifier reference.
|
|
* @param lang The language of the message.
|
|
*
|
|
* @returns The error message.
|
|
*/
|
|
/* @__NO_SIDE_EFFECTS__ */
|
|
function getSpecificMessage(reference, lang) {
|
|
return store$1?.get(reference)?.get(lang);
|
|
}
|
|
/**
|
|
* Stringifies an unknown input to a literal or type string.
|
|
*
|
|
* @param input The unknown input.
|
|
*
|
|
* @returns A literal or type string.
|
|
*
|
|
* @internal
|
|
*/
|
|
/* @__NO_SIDE_EFFECTS__ */
|
|
function _stringify(input) {
|
|
const type = typeof input;
|
|
if (type === "string") return `"${input}"`;
|
|
if (type === "number" || type === "bigint" || type === "boolean") return `${input}`;
|
|
if (type === "object" || type === "function") return (input && Object.getPrototypeOf(input)?.constructor?.name) ?? "null";
|
|
return type;
|
|
}
|
|
/**
|
|
* Adds an issue to the dataset.
|
|
*
|
|
* @param context The issue context.
|
|
* @param label The issue label.
|
|
* @param dataset The input dataset.
|
|
* @param config The configuration.
|
|
* @param other The optional props.
|
|
*
|
|
* @internal
|
|
*/
|
|
function _addIssue(context, label, dataset, config$1, other) {
|
|
const input = other && "input" in other ? other.input : dataset.value;
|
|
const expected = other?.expected ?? context.expects ?? null;
|
|
const received = other?.received ?? /* @__PURE__ */ _stringify(input);
|
|
const issue = {
|
|
kind: context.kind,
|
|
type: context.type,
|
|
input,
|
|
expected,
|
|
received,
|
|
message: `Invalid ${label}: ${expected ? `Expected ${expected} but r` : "R"}eceived ${received}`,
|
|
requirement: context.requirement,
|
|
path: other?.path,
|
|
issues: other?.issues,
|
|
lang: config$1.lang,
|
|
abortEarly: config$1.abortEarly,
|
|
abortPipeEarly: config$1.abortPipeEarly
|
|
};
|
|
const isSchema = context.kind === "schema";
|
|
const message$1 = other?.message ?? context.message ?? /* @__PURE__ */ getSpecificMessage(context.reference, issue.lang) ?? (isSchema ? /* @__PURE__ */ getSchemaMessage(issue.lang) : null) ?? config$1.message ?? /* @__PURE__ */ getGlobalMessage(issue.lang);
|
|
if (message$1 !== void 0) issue.message = typeof message$1 === "function" ? message$1(issue) : message$1;
|
|
if (isSchema) dataset.typed = false;
|
|
if (dataset.issues) dataset.issues.push(issue);
|
|
else dataset.issues = [issue];
|
|
}
|
|
/**
|
|
* Returns the Standard Schema properties.
|
|
*
|
|
* @param context The schema context.
|
|
*
|
|
* @returns The Standard Schema properties.
|
|
*/
|
|
/* @__NO_SIDE_EFFECTS__ */
|
|
function _getStandardProps(context) {
|
|
return {
|
|
version: 1,
|
|
vendor: "valibot",
|
|
validate(value$1) {
|
|
return context["~run"]({ value: value$1 }, /* @__PURE__ */ getGlobalConfig());
|
|
}
|
|
};
|
|
}
|
|
/**
|
|
* Disallows inherited object properties and prevents object prototype
|
|
* pollution by disallowing certain keys.
|
|
*
|
|
* @param object The object to check.
|
|
* @param key The key to check.
|
|
*
|
|
* @returns Whether the key is allowed.
|
|
*
|
|
* @internal
|
|
*/
|
|
/* @__NO_SIDE_EFFECTS__ */
|
|
function _isValidObjectKey(object$1, key) {
|
|
return Object.hasOwn(object$1, key) && key !== "__proto__" && key !== "prototype" && key !== "constructor";
|
|
}
|
|
/**
|
|
* Joins multiple `expects` values with the given separator.
|
|
*
|
|
* @param values The `expects` values.
|
|
* @param separator The separator.
|
|
*
|
|
* @returns The joined `expects` property.
|
|
*
|
|
* @internal
|
|
*/
|
|
/* @__NO_SIDE_EFFECTS__ */
|
|
function _joinExpects(values$1, separator) {
|
|
const list = [...new Set(values$1)];
|
|
if (list.length > 1) return `(${list.join(` ${separator} `)})`;
|
|
return list[0] ?? "never";
|
|
}
|
|
/**
|
|
* A Valibot error with useful information.
|
|
*/
|
|
var ValiError = class extends Error {
|
|
/**
|
|
* Creates a Valibot error with useful information.
|
|
*
|
|
* @param issues The error issues.
|
|
*/
|
|
constructor(issues) {
|
|
super(issues[0].message);
|
|
this.name = "ValiError";
|
|
this.issues = issues;
|
|
}
|
|
};
|
|
/**
|
|
* Returns the fallback value of the schema.
|
|
*
|
|
* @param schema The schema to get it from.
|
|
* @param dataset The output dataset if available.
|
|
* @param config The config if available.
|
|
*
|
|
* @returns The fallback value.
|
|
*/
|
|
/* @__NO_SIDE_EFFECTS__ */
|
|
function getFallback(schema, dataset, config$1) {
|
|
return typeof schema.fallback === "function" ? schema.fallback(dataset, config$1) : schema.fallback;
|
|
}
|
|
/**
|
|
* Returns the default value of the schema.
|
|
*
|
|
* @param schema The schema to get it from.
|
|
* @param dataset The input dataset if available.
|
|
* @param config The config if available.
|
|
*
|
|
* @returns The default value.
|
|
*/
|
|
/* @__NO_SIDE_EFFECTS__ */
|
|
function getDefault(schema, dataset, config$1) {
|
|
return typeof schema.default === "function" ? schema.default(dataset, config$1) : schema.default;
|
|
}
|
|
/**
|
|
* Creates an any schema.
|
|
*
|
|
* Hint: This schema function exists only for completeness and is not
|
|
* recommended in practice. Instead, `unknown` should be used to accept
|
|
* unknown data.
|
|
*
|
|
* @returns An any schema.
|
|
*/
|
|
/* @__NO_SIDE_EFFECTS__ */
|
|
function any() {
|
|
return {
|
|
kind: "schema",
|
|
type: "any",
|
|
reference: any,
|
|
expects: "any",
|
|
async: false,
|
|
get "~standard"() {
|
|
return /* @__PURE__ */ _getStandardProps(this);
|
|
},
|
|
"~run"(dataset) {
|
|
dataset.typed = true;
|
|
return dataset;
|
|
}
|
|
};
|
|
}
|
|
/* @__NO_SIDE_EFFECTS__ */
|
|
function array(item, message$1) {
|
|
return {
|
|
kind: "schema",
|
|
type: "array",
|
|
reference: array,
|
|
expects: "Array",
|
|
async: false,
|
|
item,
|
|
message: message$1,
|
|
get "~standard"() {
|
|
return /* @__PURE__ */ _getStandardProps(this);
|
|
},
|
|
"~run"(dataset, config$1) {
|
|
const input = dataset.value;
|
|
if (Array.isArray(input)) {
|
|
dataset.typed = true;
|
|
dataset.value = [];
|
|
for (let key = 0; key < input.length; key++) {
|
|
const value$1 = input[key];
|
|
const itemDataset = this.item["~run"]({ value: value$1 }, config$1);
|
|
if (itemDataset.issues) {
|
|
const pathItem = {
|
|
type: "array",
|
|
origin: "value",
|
|
input,
|
|
key,
|
|
value: value$1
|
|
};
|
|
for (const issue of itemDataset.issues) {
|
|
if (issue.path) issue.path.unshift(pathItem);
|
|
else issue.path = [pathItem];
|
|
dataset.issues?.push(issue);
|
|
}
|
|
if (!dataset.issues) dataset.issues = itemDataset.issues;
|
|
if (config$1.abortEarly) {
|
|
dataset.typed = false;
|
|
break;
|
|
}
|
|
}
|
|
if (!itemDataset.typed) dataset.typed = false;
|
|
dataset.value.push(itemDataset.value);
|
|
}
|
|
} else _addIssue(this, "type", dataset, config$1);
|
|
return dataset;
|
|
}
|
|
};
|
|
}
|
|
/* @__NO_SIDE_EFFECTS__ */
|
|
function boolean(message$1) {
|
|
return {
|
|
kind: "schema",
|
|
type: "boolean",
|
|
reference: boolean,
|
|
expects: "boolean",
|
|
async: false,
|
|
message: message$1,
|
|
get "~standard"() {
|
|
return /* @__PURE__ */ _getStandardProps(this);
|
|
},
|
|
"~run"(dataset, config$1) {
|
|
if (typeof dataset.value === "boolean") dataset.typed = true;
|
|
else _addIssue(this, "type", dataset, config$1);
|
|
return dataset;
|
|
}
|
|
};
|
|
}
|
|
/* @__NO_SIDE_EFFECTS__ */
|
|
function exactOptional(wrapped, default_) {
|
|
return {
|
|
kind: "schema",
|
|
type: "exact_optional",
|
|
reference: exactOptional,
|
|
expects: wrapped.expects,
|
|
async: false,
|
|
wrapped,
|
|
default: default_,
|
|
get "~standard"() {
|
|
return /* @__PURE__ */ _getStandardProps(this);
|
|
},
|
|
"~run"(dataset, config$1) {
|
|
return this.wrapped["~run"](dataset, config$1);
|
|
}
|
|
};
|
|
}
|
|
/* @__NO_SIDE_EFFECTS__ */
|
|
function literal(literal_, message$1) {
|
|
return {
|
|
kind: "schema",
|
|
type: "literal",
|
|
reference: literal,
|
|
expects: /* @__PURE__ */ _stringify(literal_),
|
|
async: false,
|
|
literal: literal_,
|
|
message: message$1,
|
|
get "~standard"() {
|
|
return /* @__PURE__ */ _getStandardProps(this);
|
|
},
|
|
"~run"(dataset, config$1) {
|
|
if (dataset.value === this.literal) dataset.typed = true;
|
|
else _addIssue(this, "type", dataset, config$1);
|
|
return dataset;
|
|
}
|
|
};
|
|
}
|
|
/* @__NO_SIDE_EFFECTS__ */
|
|
function object(entries$1, message$1) {
|
|
return {
|
|
kind: "schema",
|
|
type: "object",
|
|
reference: object,
|
|
expects: "Object",
|
|
async: false,
|
|
entries: entries$1,
|
|
message: message$1,
|
|
get "~standard"() {
|
|
return /* @__PURE__ */ _getStandardProps(this);
|
|
},
|
|
"~run"(dataset, config$1) {
|
|
const input = dataset.value;
|
|
if (input && typeof input === "object") {
|
|
dataset.typed = true;
|
|
dataset.value = {};
|
|
for (const key in this.entries) {
|
|
const valueSchema = this.entries[key];
|
|
if (key in input || (valueSchema.type === "exact_optional" || valueSchema.type === "optional" || valueSchema.type === "nullish") && valueSchema.default !== void 0) {
|
|
const value$1 = key in input ? input[key] : /* @__PURE__ */ getDefault(valueSchema);
|
|
const valueDataset = valueSchema["~run"]({ value: value$1 }, config$1);
|
|
if (valueDataset.issues) {
|
|
const pathItem = {
|
|
type: "object",
|
|
origin: "value",
|
|
input,
|
|
key,
|
|
value: value$1
|
|
};
|
|
for (const issue of valueDataset.issues) {
|
|
if (issue.path) issue.path.unshift(pathItem);
|
|
else issue.path = [pathItem];
|
|
dataset.issues?.push(issue);
|
|
}
|
|
if (!dataset.issues) dataset.issues = valueDataset.issues;
|
|
if (config$1.abortEarly) {
|
|
dataset.typed = false;
|
|
break;
|
|
}
|
|
}
|
|
if (!valueDataset.typed) dataset.typed = false;
|
|
dataset.value[key] = valueDataset.value;
|
|
} else if (valueSchema.fallback !== void 0) dataset.value[key] = /* @__PURE__ */ getFallback(valueSchema);
|
|
else if (valueSchema.type !== "exact_optional" && valueSchema.type !== "optional" && valueSchema.type !== "nullish") {
|
|
_addIssue(this, "key", dataset, config$1, {
|
|
input: void 0,
|
|
expected: `"${key}"`,
|
|
path: [{
|
|
type: "object",
|
|
origin: "key",
|
|
input,
|
|
key,
|
|
value: input[key]
|
|
}]
|
|
});
|
|
if (config$1.abortEarly) break;
|
|
}
|
|
}
|
|
} else _addIssue(this, "type", dataset, config$1);
|
|
return dataset;
|
|
}
|
|
};
|
|
}
|
|
/* @__NO_SIDE_EFFECTS__ */
|
|
function optional(wrapped, default_) {
|
|
return {
|
|
kind: "schema",
|
|
type: "optional",
|
|
reference: optional,
|
|
expects: `(${wrapped.expects} | undefined)`,
|
|
async: false,
|
|
wrapped,
|
|
default: default_,
|
|
get "~standard"() {
|
|
return /* @__PURE__ */ _getStandardProps(this);
|
|
},
|
|
"~run"(dataset, config$1) {
|
|
if (dataset.value === void 0) {
|
|
if (this.default !== void 0) dataset.value = /* @__PURE__ */ getDefault(this, dataset, config$1);
|
|
if (dataset.value === void 0) {
|
|
dataset.typed = true;
|
|
return dataset;
|
|
}
|
|
}
|
|
return this.wrapped["~run"](dataset, config$1);
|
|
}
|
|
};
|
|
}
|
|
/* @__NO_SIDE_EFFECTS__ */
|
|
function record(key, value$1, message$1) {
|
|
return {
|
|
kind: "schema",
|
|
type: "record",
|
|
reference: record,
|
|
expects: "Object",
|
|
async: false,
|
|
key,
|
|
value: value$1,
|
|
message: message$1,
|
|
get "~standard"() {
|
|
return /* @__PURE__ */ _getStandardProps(this);
|
|
},
|
|
"~run"(dataset, config$1) {
|
|
const input = dataset.value;
|
|
if (input && typeof input === "object") {
|
|
dataset.typed = true;
|
|
dataset.value = {};
|
|
for (const entryKey in input) if (/* @__PURE__ */ _isValidObjectKey(input, entryKey)) {
|
|
const entryValue = input[entryKey];
|
|
const keyDataset = this.key["~run"]({ value: entryKey }, config$1);
|
|
if (keyDataset.issues) {
|
|
const pathItem = {
|
|
type: "object",
|
|
origin: "key",
|
|
input,
|
|
key: entryKey,
|
|
value: entryValue
|
|
};
|
|
for (const issue of keyDataset.issues) {
|
|
issue.path = [pathItem];
|
|
dataset.issues?.push(issue);
|
|
}
|
|
if (!dataset.issues) dataset.issues = keyDataset.issues;
|
|
if (config$1.abortEarly) {
|
|
dataset.typed = false;
|
|
break;
|
|
}
|
|
}
|
|
const valueDataset = this.value["~run"]({ value: entryValue }, config$1);
|
|
if (valueDataset.issues) {
|
|
const pathItem = {
|
|
type: "object",
|
|
origin: "value",
|
|
input,
|
|
key: entryKey,
|
|
value: entryValue
|
|
};
|
|
for (const issue of valueDataset.issues) {
|
|
if (issue.path) issue.path.unshift(pathItem);
|
|
else issue.path = [pathItem];
|
|
dataset.issues?.push(issue);
|
|
}
|
|
if (!dataset.issues) dataset.issues = valueDataset.issues;
|
|
if (config$1.abortEarly) {
|
|
dataset.typed = false;
|
|
break;
|
|
}
|
|
}
|
|
if (!keyDataset.typed || !valueDataset.typed) dataset.typed = false;
|
|
if (keyDataset.typed) dataset.value[keyDataset.value] = valueDataset.value;
|
|
}
|
|
} else _addIssue(this, "type", dataset, config$1);
|
|
return dataset;
|
|
}
|
|
};
|
|
}
|
|
/* @__NO_SIDE_EFFECTS__ */
|
|
function strictObject$1(entries$1, message$1) {
|
|
return {
|
|
kind: "schema",
|
|
type: "strict_object",
|
|
reference: strictObject$1,
|
|
expects: "Object",
|
|
async: false,
|
|
entries: entries$1,
|
|
message: message$1,
|
|
get "~standard"() {
|
|
return /* @__PURE__ */ _getStandardProps(this);
|
|
},
|
|
"~run"(dataset, config$1) {
|
|
const input = dataset.value;
|
|
if (input && typeof input === "object") {
|
|
dataset.typed = true;
|
|
dataset.value = {};
|
|
for (const key in this.entries) {
|
|
const valueSchema = this.entries[key];
|
|
if (key in input || (valueSchema.type === "exact_optional" || valueSchema.type === "optional" || valueSchema.type === "nullish") && valueSchema.default !== void 0) {
|
|
const value$1 = key in input ? input[key] : /* @__PURE__ */ getDefault(valueSchema);
|
|
const valueDataset = valueSchema["~run"]({ value: value$1 }, config$1);
|
|
if (valueDataset.issues) {
|
|
const pathItem = {
|
|
type: "object",
|
|
origin: "value",
|
|
input,
|
|
key,
|
|
value: value$1
|
|
};
|
|
for (const issue of valueDataset.issues) {
|
|
if (issue.path) issue.path.unshift(pathItem);
|
|
else issue.path = [pathItem];
|
|
dataset.issues?.push(issue);
|
|
}
|
|
if (!dataset.issues) dataset.issues = valueDataset.issues;
|
|
if (config$1.abortEarly) {
|
|
dataset.typed = false;
|
|
break;
|
|
}
|
|
}
|
|
if (!valueDataset.typed) dataset.typed = false;
|
|
dataset.value[key] = valueDataset.value;
|
|
} else if (valueSchema.fallback !== void 0) dataset.value[key] = /* @__PURE__ */ getFallback(valueSchema);
|
|
else if (valueSchema.type !== "exact_optional" && valueSchema.type !== "optional" && valueSchema.type !== "nullish") {
|
|
_addIssue(this, "key", dataset, config$1, {
|
|
input: void 0,
|
|
expected: `"${key}"`,
|
|
path: [{
|
|
type: "object",
|
|
origin: "key",
|
|
input,
|
|
key,
|
|
value: input[key]
|
|
}]
|
|
});
|
|
if (config$1.abortEarly) break;
|
|
}
|
|
}
|
|
if (!dataset.issues || !config$1.abortEarly) {
|
|
for (const key in input) if (!(key in this.entries)) {
|
|
_addIssue(this, "key", dataset, config$1, {
|
|
input: key,
|
|
expected: "never",
|
|
path: [{
|
|
type: "object",
|
|
origin: "key",
|
|
input,
|
|
key,
|
|
value: input[key]
|
|
}]
|
|
});
|
|
break;
|
|
}
|
|
}
|
|
} else _addIssue(this, "type", dataset, config$1);
|
|
return dataset;
|
|
}
|
|
};
|
|
}
|
|
/* @__NO_SIDE_EFFECTS__ */
|
|
function string(message$1) {
|
|
return {
|
|
kind: "schema",
|
|
type: "string",
|
|
reference: string,
|
|
expects: "string",
|
|
async: false,
|
|
message: message$1,
|
|
get "~standard"() {
|
|
return /* @__PURE__ */ _getStandardProps(this);
|
|
},
|
|
"~run"(dataset, config$1) {
|
|
if (typeof dataset.value === "string") dataset.typed = true;
|
|
else _addIssue(this, "type", dataset, config$1);
|
|
return dataset;
|
|
}
|
|
};
|
|
}
|
|
/**
|
|
* Returns the sub issues of the provided datasets for the union issue.
|
|
*
|
|
* @param datasets The datasets.
|
|
*
|
|
* @returns The sub issues.
|
|
*
|
|
* @internal
|
|
*/
|
|
/* @__NO_SIDE_EFFECTS__ */
|
|
function _subIssues(datasets) {
|
|
let issues;
|
|
if (datasets) for (const dataset of datasets) if (issues) issues.push(...dataset.issues);
|
|
else issues = dataset.issues;
|
|
return issues;
|
|
}
|
|
/* @__NO_SIDE_EFFECTS__ */
|
|
function union(options, message$1) {
|
|
return {
|
|
kind: "schema",
|
|
type: "union",
|
|
reference: union,
|
|
expects: /* @__PURE__ */ _joinExpects(options.map((option) => option.expects), "|"),
|
|
async: false,
|
|
options,
|
|
message: message$1,
|
|
get "~standard"() {
|
|
return /* @__PURE__ */ _getStandardProps(this);
|
|
},
|
|
"~run"(dataset, config$1) {
|
|
let validDataset;
|
|
let typedDatasets;
|
|
let untypedDatasets;
|
|
for (const schema of this.options) {
|
|
const optionDataset = schema["~run"]({ value: dataset.value }, config$1);
|
|
if (optionDataset.typed) if (optionDataset.issues) if (typedDatasets) typedDatasets.push(optionDataset);
|
|
else typedDatasets = [optionDataset];
|
|
else {
|
|
validDataset = optionDataset;
|
|
break;
|
|
}
|
|
else if (untypedDatasets) untypedDatasets.push(optionDataset);
|
|
else untypedDatasets = [optionDataset];
|
|
}
|
|
if (validDataset) return validDataset;
|
|
if (typedDatasets) {
|
|
if (typedDatasets.length === 1) return typedDatasets[0];
|
|
_addIssue(this, "type", dataset, config$1, { issues: /* @__PURE__ */ _subIssues(typedDatasets) });
|
|
dataset.typed = true;
|
|
} else if (untypedDatasets?.length === 1) return untypedDatasets[0];
|
|
else _addIssue(this, "type", dataset, config$1, { issues: /* @__PURE__ */ _subIssues(untypedDatasets) });
|
|
return dataset;
|
|
}
|
|
};
|
|
}
|
|
/**
|
|
* Parses an unknown input based on a schema.
|
|
*
|
|
* @param schema The schema to be used.
|
|
* @param input The input to be parsed.
|
|
* @param config The parse configuration.
|
|
*
|
|
* @returns The parsed input.
|
|
*/
|
|
function parse(schema, input, config$1) {
|
|
const dataset = schema["~run"]({ value: input }, /* @__PURE__ */ getGlobalConfig(config$1));
|
|
if (dataset.issues) throw new ValiError(dataset.issues);
|
|
return dataset.value;
|
|
}
|
|
/**
|
|
* Parses an unknown input based on a schema.
|
|
*
|
|
* @param schema The schema to be used.
|
|
* @param input The input to be parsed.
|
|
* @param config The parse configuration.
|
|
*
|
|
* @returns The parse result.
|
|
*/
|
|
/* @__NO_SIDE_EFFECTS__ */
|
|
function safeParse(schema, input, config$1) {
|
|
const dataset = schema["~run"]({ value: input }, /* @__PURE__ */ getGlobalConfig(config$1));
|
|
return {
|
|
typed: dataset.typed,
|
|
success: !dataset.issues,
|
|
output: dataset.value,
|
|
issues: dataset.issues
|
|
};
|
|
}
|
|
//#endregion
|
|
//#region src/schema.ts
|
|
const baseBoolSchema = /* @__PURE__ */ exactOptional(/* @__PURE__ */ union([/* @__PURE__ */ boolean(), /* @__PURE__ */ object({ files: /* @__PURE__ */ exactOptional(/* @__PURE__ */ array(/* @__PURE__ */ string())) })]), true);
|
|
const tsPresets = /* @__PURE__ */ union([
|
|
/* @__PURE__ */ literal("recommended"),
|
|
/* @__PURE__ */ literal("strict"),
|
|
/* @__PURE__ */ literal("recommendedTypeChecked"),
|
|
/* @__PURE__ */ literal("strictTypeChecked"),
|
|
/* @__PURE__ */ literal("all")
|
|
]);
|
|
const isInEditorSchema = /* @__PURE__ */ exactOptional(/* @__PURE__ */ boolean(), isInEditorEnv());
|
|
const typescriptSchema = /* @__PURE__ */ exactOptional(/* @__PURE__ */ union([/* @__PURE__ */ boolean(), /* @__PURE__ */ object({
|
|
files: /* @__PURE__ */ exactOptional(/* @__PURE__ */ array(/* @__PURE__ */ string())),
|
|
preset: /* @__PURE__ */ exactOptional(tsPresets, "recommended"),
|
|
projectService: /* @__PURE__ */ exactOptional(/* @__PURE__ */ boolean()),
|
|
tsconfigRootDir: /* @__PURE__ */ exactOptional(/* @__PURE__ */ string())
|
|
})]), hasPackage("typescript"));
|
|
const vueSchema = /* @__PURE__ */ exactOptional(/* @__PURE__ */ union([/* @__PURE__ */ boolean(), /* @__PURE__ */ object({
|
|
files: /* @__PURE__ */ exactOptional(/* @__PURE__ */ array(/* @__PURE__ */ string())),
|
|
a11y: /* @__PURE__ */ exactOptional(/* @__PURE__ */ boolean())
|
|
})]), hasPackage("vue") || hasPackage("@vue/compat"));
|
|
const perfectionistSchema = /* @__PURE__ */ exactOptional(/* @__PURE__ */ union([/* @__PURE__ */ boolean(), /* @__PURE__ */ object({
|
|
files: /* @__PURE__ */ exactOptional(/* @__PURE__ */ array(/* @__PURE__ */ string())),
|
|
import: /* @__PURE__ */ exactOptional(/* @__PURE__ */ boolean()),
|
|
export: /* @__PURE__ */ exactOptional(/* @__PURE__ */ boolean())
|
|
})]), true);
|
|
const autoImportsSchema = /* @__PURE__ */ exactOptional(/* @__PURE__ */ union([/* @__PURE__ */ boolean(), /* @__PURE__ */ object({
|
|
files: /* @__PURE__ */ exactOptional(/* @__PURE__ */ array(/* @__PURE__ */ string())),
|
|
src: /* @__PURE__ */ exactOptional(/* @__PURE__ */ union([/* @__PURE__ */ string(), /* @__PURE__ */ object({ globals: /* @__PURE__ */ record(/* @__PURE__ */ string(), /* @__PURE__ */ union([
|
|
/* @__PURE__ */ boolean(),
|
|
/* @__PURE__ */ literal("off"),
|
|
/* @__PURE__ */ literal("readable"),
|
|
/* @__PURE__ */ literal("readonly"),
|
|
/* @__PURE__ */ literal("writable"),
|
|
/* @__PURE__ */ literal("writeable")
|
|
])) })]))
|
|
})]), true);
|
|
const stylisticSchema = /* @__PURE__ */ exactOptional(/* @__PURE__ */ union([/* @__PURE__ */ boolean(), /* @__PURE__ */ object({
|
|
files: /* @__PURE__ */ exactOptional(/* @__PURE__ */ array(/* @__PURE__ */ string())),
|
|
severity: /* @__PURE__ */ exactOptional(/* @__PURE__ */ union([/* @__PURE__ */ literal("error"), /* @__PURE__ */ literal("warn")]))
|
|
})]), hasPackage("typescript"));
|
|
const jsSchema = baseBoolSchema;
|
|
const unicornSchema = baseBoolSchema;
|
|
const jsonCSchema = baseBoolSchema;
|
|
const antfuSchema = baseBoolSchema;
|
|
const importsSchema = /* @__PURE__ */ exactOptional(/* @__PURE__ */ union([/* @__PURE__ */ boolean(), /* @__PURE__ */ object({
|
|
files: /* @__PURE__ */ exactOptional(/* @__PURE__ */ array(/* @__PURE__ */ string())),
|
|
plugin: /* @__PURE__ */ exactOptional(/* @__PURE__ */ union([/* @__PURE__ */ literal("import-lite"), /* @__PURE__ */ literal("import-x")]), "import-lite")
|
|
})]), true);
|
|
const testSchema = /* @__PURE__ */ exactOptional(/* @__PURE__ */ union([/* @__PURE__ */ boolean(), /* @__PURE__ */ object({
|
|
runner: /* @__PURE__ */ exactOptional(/* @__PURE__ */ union([/* @__PURE__ */ literal("jest"), /* @__PURE__ */ literal("vitest")])),
|
|
files: /* @__PURE__ */ exactOptional(/* @__PURE__ */ array(/* @__PURE__ */ string()))
|
|
})]), hasPackage("jest") || hasPackage("vitest"));
|
|
const gitignoreSchema = /* @__PURE__ */ exactOptional(/* @__PURE__ */ union([/* @__PURE__ */ boolean(), /* @__PURE__ */ object({
|
|
sources: /* @__PURE__ */ exactOptional(/* @__PURE__ */ array(/* @__PURE__ */ string())),
|
|
gitmodules: /* @__PURE__ */ exactOptional(/* @__PURE__ */ array(/* @__PURE__ */ string()))
|
|
})]), hasFile(".gitignore"));
|
|
const optionsSchema = /* @__PURE__ */ strictObject$1({
|
|
ts: typescriptSchema,
|
|
vue: vueSchema,
|
|
autoimports: autoImportsSchema,
|
|
perfectionist: perfectionistSchema,
|
|
isInEditor: isInEditorSchema,
|
|
stylistic: stylisticSchema,
|
|
test: testSchema,
|
|
pnpm: /* @__PURE__ */ exactOptional(/* @__PURE__ */ union([/* @__PURE__ */ boolean(), /* @__PURE__ */ object({
|
|
files: /* @__PURE__ */ exactOptional(/* @__PURE__ */ array(/* @__PURE__ */ string())),
|
|
enforceCatalog: /* @__PURE__ */ exactOptional(/* @__PURE__ */ boolean())
|
|
})])),
|
|
gitignore: gitignoreSchema,
|
|
ignore: /* @__PURE__ */ exactOptional(/* @__PURE__ */ union([/* @__PURE__ */ boolean(), /* @__PURE__ */ object({
|
|
ignore: /* @__PURE__ */ exactOptional(/* @__PURE__ */ array(/* @__PURE__ */ string())),
|
|
extendIgnore: /* @__PURE__ */ exactOptional(/* @__PURE__ */ array(/* @__PURE__ */ string()))
|
|
})]), true),
|
|
js: jsSchema,
|
|
imports: importsSchema,
|
|
unicorn: unicornSchema,
|
|
json: jsonCSchema,
|
|
antfu: antfuSchema
|
|
});
|
|
function validateOptions(options) {
|
|
return parse(optionsSchema, options);
|
|
}
|
|
const strictObject = /* @__PURE__ */ strictObject$1({});
|
|
function getFirstConfigType(maybeConfig) {
|
|
if ((/* @__PURE__ */ safeParse(strictObject, maybeConfig)).success) return "options";
|
|
if ((/* @__PURE__ */ safeParse(optionsSchema, maybeConfig)).success) return "options";
|
|
return "config";
|
|
}
|
|
//#endregion
|
|
//#region src/builder.ts
|
|
async function buildConfig(maybeOptions, ...userConfigs) {
|
|
const maybeConfigType = getFirstConfigType(maybeOptions ?? {});
|
|
const vOptions = maybeConfigType === "options" ? validateOptions(maybeOptions ?? {}) : validateOptions({});
|
|
const configsToCompose = [];
|
|
if (vOptions.js) configsToCompose.push(js(vOptions.js));
|
|
if (vOptions.gitignore) configsToCompose.push(gitignore(vOptions.gitignore));
|
|
if (vOptions.autoimports) configsToCompose.push(autoimports(vOptions.autoimports));
|
|
if (vOptions.ts) configsToCompose.push(typescript(vOptions.ts));
|
|
if (vOptions.vue) configsToCompose.push(vue(vOptions.vue, vOptions.ts));
|
|
if (vOptions.perfectionist) configsToCompose.push(perfectionist(vOptions.perfectionist));
|
|
if (vOptions.stylistic) configsToCompose.push(stylistic(vOptions.stylistic, vOptions.vue));
|
|
if (vOptions.imports) configsToCompose.push(imports(vOptions.imports));
|
|
if (vOptions.unicorn) configsToCompose.push(unicorn(vOptions.unicorn));
|
|
if (vOptions.ignore) configsToCompose.push(ignore(vOptions.ignore));
|
|
if (vOptions.test) configsToCompose.push(test(vOptions.test));
|
|
if (vOptions.antfu) configsToCompose.push(antfu(vOptions.antfu));
|
|
if (vOptions.pnpm === void 0 ? (await getPackageManager())?.name === "pnpm" : Boolean(vOptions.pnpm)) configsToCompose.push(pnpm(vOptions.pnpm));
|
|
if (maybeConfigType === "config" && maybeOptions) configsToCompose.push(maybeOptions);
|
|
let composed = composer(await concat(...configsToCompose, ...userConfigs));
|
|
if (vOptions?.isInEditor ?? false) composed = composed.disableRulesFix([
|
|
"unused-imports/no-unused-imports",
|
|
"test/no-only-tests",
|
|
"prefer-const"
|
|
], { builtinRules: () => import(["eslint", "use-at-your-own-risk"].join("/")).then((r) => r.builtinRules) });
|
|
return composed;
|
|
}
|
|
//#endregion
|
|
export { buildConfig as default };
|