@brnshkr/config 0.0.1-alpha.10

package/dist/stylelint/index.mjs

@@ -0,0 +1,409 @@
+import { a as isModuleEnabledByDefault, b as packageOrganization, d as MODULES, f as PACKAGES, h as setModuleEnabled, i as GLOB_IGNORES, m as resolvePackages, n as MAX_LEN, p as isModuleEnabled, r as QUOTES, s as objectEntries, t as INDENT } from "../shared.mjs";
+
+//#region src/js/stylelint/configs/baseline.ts
+const baseline = () => {
+	const { requiredAll: [isStylelintPluginUseBaselineInstalled] } = resolvePackages(MODULES.baseline);
+	if (!isStylelintPluginUseBaselineInstalled) return [];
+	return [{
+		plugins: PACKAGES.STYLELINT_PLUGIN_USE_BASELINE,
+		rules: { "plugin/use-baseline": true }
+	}];
+};
+
+//#endregion
+//#region src/js/stylelint/configs/css.ts
+const css = () => [{
+	extends: "stylelint-config-standard",
+	reportDescriptionlessDisables: true,
+	reportInvalidScopeDisables: true,
+	reportNeedlessDisables: true,
+	reportUnscopedDisables: true,
+	rules: {
+		"at-rule-disallowed-list": ["debug"],
+		"at-rule-property-required-list": { "font-face": [
+			"font-display",
+			"font-family",
+			"font-style",
+			"font-weight",
+			"src"
+		] },
+		"color-hex-length": "long",
+		"color-named": "never",
+		"color-no-invalid-hex": true,
+		"comment-word-disallowed-list": [new RegExp(`^${["TO", "DO"].join("")}`, "v")],
+		"declaration-no-important": true,
+		"declaration-property-value-disallowed-list": {
+			border: ["none"],
+			"border-top": ["none"],
+			"border-right": ["none"],
+			"border-bottom": ["none"],
+			"border-left": ["none"]
+		},
+		"declaration-property-unit-allowed-list": {
+			"/^animation/": "ms",
+			"/^transition/": "ms",
+			"font-size": ["em", "rem"],
+			"line-height": []
+		},
+		"font-family-name-quotes": "always-unless-keyword",
+		"font-weight-notation": "numeric",
+		"function-linear-gradient-no-nonstandard-direction": true,
+		"function-no-unknown": true,
+		"function-url-no-scheme-relative": true,
+		"function-url-scheme-allowed-list": ["data", "https"],
+		"max-nesting-depth": 3,
+		"no-unknown-animations": true,
+		"no-unknown-custom-media": true,
+		"no-unknown-custom-properties": true,
+		"selector-class-pattern": ["^[a-z]([-]?[a-z0-9]+)*(__[a-z0-9]([-]?[a-z0-9]+)*)?(--[a-z0-9]([-]?[a-z0-9]+)*)?$", {
+			resolveNestedSelectors: true,
+			message: (value) => `Expected class selector "${value}" to match BEM methodology (https://getbem.com/). Selector validation tool: https://regexr.com/3apms`
+		}],
+		"string-no-newline": true,
+		"unit-no-unknown": true,
+		"value-keyword-case": ["lower", {
+			camelCaseSvgKeywords: true,
+			ignoreKeywords: [/^geometricPrecision$/v]
+		}]
+	}
+}];
+
+//#endregion
+//#region src/js/stylelint/configs/defensive.ts
+const defensive = () => {
+	const { requiredAll: [isStylelintPluginDefensiveCssInstalled] } = resolvePackages(MODULES.defensive);
+	if (!isStylelintPluginDefensiveCssInstalled) return [];
+	return [{
+		plugins: PACKAGES.STYLELINT_PLUGIN_DEFENSIVE_CSS,
+		rules: { "plugin/use-defensive-css": [true, {
+			"accidental-hover": true,
+			"background-repeat": true,
+			"flex-wrapping": true,
+			"scroll-chaining": true,
+			"scrollbar-gutter": true,
+			"vendor-prefix-grouping": true
+		}] }
+	}];
+};
+
+//#endregion
+//#region src/js/stylelint/types/overrides.ts
+const OVERRIDES = {
+	SCSS: "scss",
+	SVELTE: "svelte"
+};
+
+//#endregion
+//#region src/js/stylelint/utils/config.ts
+const buildOverrideName = (override) => [packageOrganization, override].filter(Boolean).join("/");
+const isValidGlobalAdditionalConfigKey = (key) => [
+	"extends",
+	"plugins",
+	"pluginFunctions",
+	"ignoreFiles",
+	"rules",
+	"quiet",
+	"formatter",
+	"defaultSeverity",
+	"ignoreDisables",
+	"reportNeedlessDisables",
+	"reportInvalidScopeDisables",
+	"reportDescriptionlessDisables",
+	"reportUnscopedDisables",
+	"configurationComment",
+	"overrides",
+	"customSyntax",
+	"processors",
+	"languageOptions",
+	"allowEmptyInput",
+	"cache",
+	"fix",
+	"computeEditInfo",
+	"validate"
+].includes(key);
+const getGlobalAdditionalConfig = (options) => {
+	const config = {};
+	for (const [key, value] of objectEntries(options)) if (isValidGlobalAdditionalConfigKey(key)) config[key] = value;
+	if (Object.keys(config).length === 0) return;
+	return config;
+};
+const getUserConfigs = (resolvedOptions, additionalConfigs) => [getGlobalAdditionalConfig(resolvedOptions), ...additionalConfigs].filter(Boolean);
+const includeConfigs = (config, configsToInclude) => {
+	for (const configToInclude of configsToInclude) {
+		if (configToInclude.extends !== void 0) config.extends = [...new Set([...Array.isArray(config.extends) ? config.extends ?? [] : [config.extends].filter(Boolean), ...Array.isArray(configToInclude.extends) ? configToInclude.extends ?? [] : [configToInclude.extends].filter(Boolean)])];
+		if (configToInclude.plugins !== void 0) config.plugins = [...new Set([...Array.isArray(config.plugins) ? config.plugins ?? [] : [config.plugins].filter(Boolean), ...Array.isArray(configToInclude.plugins) ? configToInclude.plugins ?? [] : [configToInclude.plugins].filter(Boolean)])];
+		if (configToInclude.pluginFunctions !== void 0) config.pluginFunctions = {
+			...config.pluginFunctions,
+			...configToInclude.pluginFunctions
+		};
+		if (configToInclude.ignoreFiles !== void 0) config.ignoreFiles = [...new Set([...Array.isArray(config.ignoreFiles) ? config.ignoreFiles ?? [] : [config.ignoreFiles].filter(Boolean), ...Array.isArray(configToInclude.ignoreFiles) ? configToInclude.ignoreFiles ?? [] : [configToInclude.ignoreFiles].filter(Boolean)])];
+		if (configToInclude.rules !== void 0) config.rules = {
+			...config.rules,
+			...configToInclude.rules
+		};
+		if (configToInclude.quiet !== void 0) config.quiet = configToInclude.quiet;
+		if (configToInclude.formatter !== void 0) config.formatter = configToInclude.formatter;
+		if (configToInclude.defaultSeverity !== void 0) config.defaultSeverity = configToInclude.defaultSeverity;
+		if (configToInclude.ignoreDisables !== void 0) config.ignoreDisables = configToInclude.ignoreDisables;
+		if (configToInclude.reportNeedlessDisables !== void 0) config.reportNeedlessDisables = configToInclude.reportNeedlessDisables;
+		if (configToInclude.reportInvalidScopeDisables !== void 0) config.reportInvalidScopeDisables = configToInclude.reportInvalidScopeDisables;
+		if (configToInclude.reportDescriptionlessDisables !== void 0) config.reportDescriptionlessDisables = configToInclude.reportDescriptionlessDisables;
+		if (configToInclude.reportUnscopedDisables !== void 0) config.reportUnscopedDisables = configToInclude.reportUnscopedDisables;
+		if (configToInclude.configurationComment !== void 0) config.configurationComment = configToInclude.configurationComment;
+		if (configToInclude.overrides !== void 0) {
+			const overridesToIncude = configToInclude.overrides;
+			config.overrides = [...(config.overrides ?? []).filter((existingOverride) => !overridesToIncude.some((overrideToIncude) => overrideToIncude.name !== void 0 && overrideToIncude.name === existingOverride.name)), ...overridesToIncude];
+		}
+		if (configToInclude.customSyntax !== void 0) config.customSyntax = configToInclude.customSyntax;
+		if (configToInclude.processors !== void 0) config.processors = [...new Set([...config.processors ?? [], ...configToInclude.processors])];
+		if (configToInclude.languageOptions !== void 0) config.languageOptions = {
+			...config.languageOptions,
+			...configToInclude.languageOptions,
+			syntax: {
+				atRules: {
+					...config.languageOptions?.syntax?.atRules,
+					...configToInclude.languageOptions.syntax?.atRules
+				},
+				cssWideKeywords: [...new Set([...config.languageOptions?.syntax?.cssWideKeywords ?? [], ...configToInclude.languageOptions.syntax?.cssWideKeywords ?? []])],
+				properties: {
+					...config.languageOptions?.syntax?.properties,
+					...configToInclude.languageOptions.syntax?.properties
+				},
+				types: {
+					...config.languageOptions?.syntax?.types,
+					...configToInclude.languageOptions.syntax?.types
+				}
+			}
+		};
+		if (configToInclude.allowEmptyInput !== void 0) config.allowEmptyInput = configToInclude.allowEmptyInput;
+		if (configToInclude.cache !== void 0) config.cache = configToInclude.cache;
+		if (configToInclude.fix !== void 0) config.fix = configToInclude.fix;
+		if (configToInclude.computeEditInfo !== void 0) config.computeEditInfo = configToInclude.computeEditInfo;
+		if (configToInclude.validate !== void 0) config.validate = configToInclude.validate;
+	}
+};
+
+//#endregion
+//#region src/js/stylelint/configs/html.ts
+const html = () => {
+	const { requiredAll: [isPostcssHtmlInstalled, isStylelintConfigHtmlInstalled] } = resolvePackages(MODULES.html);
+	if (!isPostcssHtmlInstalled || !isStylelintConfigHtmlInstalled) return [];
+	return [{
+		extends: PACKAGES.STYLELINT_CONFIG_HTML,
+		overrides: [{
+			name: buildOverrideName(OVERRIDES.SVELTE),
+			files: ["**/*.svelte"],
+			rules: {
+				"keyframes-name-pattern": ["^(-global-)?([a-z][a-z0-9]*)(-[a-z0-9]+)*$", { message: (name) => `Expected keyframe name "${name}" to be kebab-case` }],
+				"selector-pseudo-class-no-unknown": [true, { ignorePseudoClasses: ["global"] }]
+			}
+		}]
+	}];
+};
+
+//#endregion
+//#region src/js/stylelint/configs/ignores.ts
+const ignores = () => [{ ignoreFiles: GLOB_IGNORES.map((glob) => glob.replace(/^\*\*/v, process.cwd())) }];
+
+//#endregion
+//#region src/js/stylelint/configs/logical.ts
+const logical = () => {
+	const { requiredAll: [isStylelintPluginLogicalCssInstalled] } = resolvePackages(MODULES.logical);
+	if (!isStylelintPluginLogicalCssInstalled) return [];
+	return [{
+		plugins: PACKAGES.STYLELINT_PLUGIN_LOGICAL_CSS,
+		rules: {
+			"plugin/use-logical-properties-and-values": true,
+			"plugin/use-logical-units": true
+		}
+	}];
+};
+
+//#endregion
+//#region src/js/stylelint/configs/modules.ts
+const modules = () => {
+	const { requiredAll: [isStylelintConfigCssModulesInstalled] } = resolvePackages(MODULES.modules);
+	if (!isStylelintConfigCssModulesInstalled) return [];
+	return [{ extends: PACKAGES.STYLELINT_CONFIG_CSS_MODULES }];
+};
+
+//#endregion
+//#region src/js/stylelint/configs/nesting.ts
+const nesting = () => {
+	const { requiredAll: [isStylelintUseNestingInstalled] } = resolvePackages(MODULES.nesting);
+	if (!isStylelintUseNestingInstalled) return [];
+	return [{
+		plugins: PACKAGES.STYLELINT_USE_NESTING,
+		rules: { "csstools/use-nesting": ["always", { syntax: isModuleEnabled(MODULES.scss) ? "scss" : "css" }] }
+	}];
+};
+
+//#endregion
+//#region src/js/stylelint/configs/order.ts
+const order = () => {
+	const { requiredAll: [isStylelintConfigRecessOrderInstalled] } = resolvePackages(MODULES.order);
+	if (!isStylelintConfigRecessOrderInstalled) return [];
+	return [{ extends: PACKAGES.STYLELINT_CONFIG_RECESS_ORDER }];
+};
+
+//#endregion
+//#region src/js/stylelint/configs/scss.ts
+const scss = () => {
+	const { requiredAll: [isStylelintConfigStandardScssInstalled], optional: [isStylelintPluginUseBaselineInstalled] } = resolvePackages(MODULES.scss);
+	if (!isStylelintConfigStandardScssInstalled) return [];
+	return [{
+		extends: PACKAGES.STYLELINT_CONFIG_STANDARD_SCSS,
+		rules: {
+			"scss/at-each-key-value-single-line": true,
+			"scss/at-mixin-argumentless-call-parentheses": "always",
+			"scss/at-mixin-no-risky-nesting-selector": true,
+			"scss/at-root-no-redundant": true,
+			"scss/at-use-no-redundant-alias": true,
+			"scss/block-no-redundant-nesting": true,
+			"scss/declaration-nested-properties": "never",
+			"scss/dimension-no-non-numeric-values": true,
+			"scss/dollar-variable-first-in-block": [true, {
+				ignore: ["comments", "imports"],
+				except: [
+					"function",
+					"mixin",
+					"if-else",
+					"loops"
+				]
+			}],
+			"scss/dollar-variable-no-namespaced-assignment": true,
+			"scss/double-slash-comment-inline": "never",
+			"scss/function-color-channel": true,
+			"scss/function-color-relative": true,
+			"scss/map-keys-quotes": "always",
+			"scss/no-duplicate-dollar-variables": [true, {
+				ignoreInsideAtRules: ["if", "mixin"],
+				ignoreDefaults: false
+			}],
+			"scss/no-duplicate-load-rules": true,
+			"scss/no-unused-private-members": true,
+			"scss/partial-no-import": true,
+			"scss/at-import-partial-extension-disallowed-list": ["scss"],
+			"property-no-unknown": null,
+			"scss/property-no-unknown": true,
+			"scss/selector-no-redundant-nesting-selector": true
+		},
+		overrides: [{
+			name: buildOverrideName(OVERRIDES.SCSS),
+			files: ["**/*.scss"],
+			rules: {
+				"scss/comment-no-loud": true,
+				...isStylelintPluginUseBaselineInstalled ? { "plugin/use-baseline": [true, { ignoreAtRules: ["function"] }] } : void 0
+			}
+		}]
+	}];
+};
+
+//#endregion
+//#region src/js/stylelint/configs/strict.ts
+const strict = () => {
+	const { requiredAll: [isStylelintDeclarationStrictValueInstalled] } = resolvePackages(MODULES.strict);
+	if (!isStylelintDeclarationStrictValueInstalled) return [];
+	return [{
+		plugins: PACKAGES.STYLELINT_DECLARATION_STRICT_VALUE,
+		rules: { "scale-unlimited/declaration-strict-value": [
+			"/color$/",
+			"font-size",
+			"z-index"
+		] }
+	}];
+};
+
+//#endregion
+//#region src/js/stylelint/configs/style.ts
+const style = () => {
+	const { requiredAll: [isStylisticStylelintConfigInstalled] } = resolvePackages(MODULES.style);
+	if (!isStylisticStylelintConfigInstalled) return [];
+	return [{
+		extends: PACKAGES.STYLISTIC_STYLELINT_CONFIG,
+		rules: {
+			"@stylistic/at-rule-name-newline-after": "always-multi-line",
+			"@stylistic/at-rule-semicolon-space-before": "never",
+			"@stylistic/block-closing-brace-newline-before": "always",
+			"@stylistic/block-opening-brace-newline-after": "always",
+			"@stylistic/declaration-block-semicolon-newline-after": "always",
+			"@stylistic/function-comma-newline-before": "never-multi-line",
+			"@stylistic/function-comma-space-before": "never-single-line",
+			"@stylistic/indentation": INDENT,
+			"@stylistic/linebreaks": "unix",
+			"@stylistic/max-line-length": MAX_LEN,
+			"@stylistic/media-query-list-comma-newline-after": "always",
+			"@stylistic/media-query-list-comma-newline-before": "never-multi-line",
+			"@stylistic/named-grid-areas-alignment": [true, { alignQuotes: true }],
+			"@stylistic/selector-list-comma-newline-before": "never-multi-line",
+			"@stylistic/string-quotes": QUOTES,
+			"@stylistic/unicode-bom": "never",
+			"@stylistic/value-list-comma-newline-before": "never-multi-line",
+			"@stylistic/value-list-comma-space-before": "never-single-line"
+		}
+	}];
+};
+
+//#endregion
+//#region src/js/stylelint/configs/index.ts
+const configs = {
+	baseline,
+	css,
+	defensive,
+	html,
+	ignores,
+	logical,
+	modules,
+	nesting,
+	order,
+	scss,
+	strict,
+	style
+};
+
+//#endregion
+//#region src/js/stylelint/index.ts
+const getConfig = (optionsAndGlobalConfig, ...additionalConfigs) => {
+	const resolvedOptions = {
+		baseline: isModuleEnabledByDefault(MODULES.baseline),
+		defensive: isModuleEnabledByDefault(MODULES.defensive),
+		html: isModuleEnabledByDefault(MODULES.html),
+		logical: isModuleEnabledByDefault(MODULES.logical),
+		modules: isModuleEnabledByDefault(MODULES.modules),
+		nesting: isModuleEnabledByDefault(MODULES.nesting),
+		order: isModuleEnabledByDefault(MODULES.order),
+		scss: isModuleEnabledByDefault(MODULES.scss),
+		strict: isModuleEnabledByDefault(MODULES.strict),
+		style: isModuleEnabledByDefault(MODULES.style),
+		...optionsAndGlobalConfig
+	};
+	setModuleEnabled(MODULES.baseline, resolvedOptions.baseline);
+	setModuleEnabled(MODULES.defensive, resolvedOptions.defensive);
+	setModuleEnabled(MODULES.html, resolvedOptions.html);
+	setModuleEnabled(MODULES.logical, resolvedOptions.logical);
+	setModuleEnabled(MODULES.modules, resolvedOptions.modules);
+	setModuleEnabled(MODULES.nesting, resolvedOptions.nesting);
+	setModuleEnabled(MODULES.order, resolvedOptions.order);
+	setModuleEnabled(MODULES.scss, resolvedOptions.scss);
+	setModuleEnabled(MODULES.strict, resolvedOptions.strict);
+	setModuleEnabled(MODULES.style, resolvedOptions.style);
+	const config = {};
+	includeConfigs(config, configs.ignores());
+	includeConfigs(config, configs.css());
+	if (isModuleEnabled(MODULES.baseline)) includeConfigs(config, configs.baseline());
+	if (isModuleEnabled(MODULES.defensive)) includeConfigs(config, configs.defensive());
+	if (isModuleEnabled(MODULES.logical)) includeConfigs(config, configs.logical());
+	if (isModuleEnabled(MODULES.nesting)) includeConfigs(config, configs.nesting());
+	if (isModuleEnabled(MODULES.order)) includeConfigs(config, configs.order());
+	if (isModuleEnabled(MODULES.scss)) includeConfigs(config, configs.scss());
+	if (isModuleEnabled(MODULES.html)) includeConfigs(config, configs.html());
+	if (isModuleEnabled(MODULES.modules)) includeConfigs(config, configs.modules());
+	if (isModuleEnabled(MODULES.strict)) includeConfigs(config, configs.strict());
+	if (isModuleEnabled(MODULES.style)) includeConfigs(config, configs.style());
+	includeConfigs(config, getUserConfigs(resolvedOptions, additionalConfigs));
+	return config;
+};
+var stylelint_default = getConfig();
+
+//#endregion
+export { stylelint_default as default, getConfig };