oxlint-plugin-vize 0.443.0 → 0.457.0

package/dist/eslint.d.mts

@@ -0,0 +1,7 @@
+import { c as createVizeRuleConfig, s as configs } from "./configs-BuOTHAnm.mjs";
+
+//#region src/eslint.d.ts
+/** ESLint rules over the complete source supplied by the configured parser. */
+declare const _default: import("@oxlint/plugins").Plugin;
+//#endregion
+export { configs, createVizeRuleConfig, _default as default };

package/dist/eslint.mjs

@@ -0,0 +1,153 @@
+import { a as getPatinaRules, c as isTypeAwareRuleName, d as getRuleOptions, i as formatPatinaMessage, l as createRuleSelection, n as createVizeRuleConfig, o as getActivePreset, r as plugin_default, s as getVizeSettings, t as configs } from "./configs-DY0BrbH2.mjs";
+import { d as isPatinaFile, m as loadBinding } from "./workaround-CiQUFJw0.mjs";
+import { definePlugin, defineRule, eslintCompatPlugin } from "@oxlint/plugins";
+//#region src/eslint-source.ts
+/** Native UTF-8 text cannot preserve an unpaired UTF-16 surrogate. */
+function assertSourceText(source) {
+	if (/[\uD800-\uDFFF]/u.test(source)) throw new Error("Vize cannot lint source containing an unpaired UTF-16 surrogate");
+}
+/** Convert only requested UTF-8 boundaries, with one scan of the UTF-16 text. */
+function mapSourceOffsets(source, offsets) {
+	const result = /* @__PURE__ */ new Map();
+	let index = 0;
+	let bytes = 0;
+	for (const offset of [...new Set(offsets)].sort((left, right) => left - right)) {
+		if (!Number.isSafeInteger(offset) || offset < 0) throw new Error("Vize returned an invalid source offset");
+		while (bytes < offset && index < source.length) {
+			const point = source.codePointAt(index);
+			bytes += point <= 127 ? 1 : point <= 2047 ? 2 : point <= 65535 ? 3 : 4;
+			index += point > 65535 ? 2 : 1;
+		}
+		if (bytes !== offset) throw new Error("Vize source offset is not a UTF-8 boundary");
+		result.set(offset, index);
+	}
+	return result;
+}
+/** Refuse invalid or overlapping native edits before handing them to a fixer. */
+function mapTextEdits(edits, offsets) {
+	let previousEnd = -1;
+	let previousStart = -1;
+	return [...edits].sort((left, right) => left.start - right.start || left.end - right.end).map((edit) => {
+		const start = offsets.get(edit.start);
+		const end = offsets.get(edit.end);
+		if (start === void 0 || end === void 0 || start > end || start < previousEnd || start === previousStart || typeof edit.newText !== "string") throw new Error("Vize returned invalid or overlapping ESLint text edits");
+		previousStart = start;
+		previousEnd = end;
+		return {
+			range: [start, end],
+			text: edit.newText
+		};
+	});
+}
+//#endregion
+//#region src/eslint.ts
+const programs = /* @__PURE__ */ new WeakMap();
+const metadata = getPatinaRules();
+const byName = new Map(metadata.map((rule) => [rule.name, rule]));
+function collect(context, program, name) {
+	const source = context.sourceCode.text;
+	let collected = programs.get(program);
+	if (!collected || collected.diagnostics) {
+		collected = {
+			source,
+			sourceCode: context.sourceCode,
+			filename: context.physicalFilename,
+			settings: structuredClone(getVizeSettings(context)),
+			options: /* @__PURE__ */ new Map()
+		};
+		programs.set(program, collected);
+	}
+	if (source !== collected.source || context.physicalFilename !== collected.filename) throw new Error("Vize source changed during ESLint rule collection");
+	collected.options.set(name, structuredClone(getRuleOptions(name, context.options)));
+}
+function run(collected) {
+	assertSourceText(collected.source);
+	const selection = createRuleSelection(collected.options);
+	const settings = collected.settings;
+	const result = loadBinding().lintPatinaSfc(collected.source, {
+		filename: collected.filename,
+		locale: settings.locale,
+		helpLevel: settings.helpLevel,
+		preset: getActivePreset(settings),
+		enabledRules: selection.names,
+		typeAware: settings.typeAware === true || selection.names.some(isTypeAwareRuleName),
+		corsaPath: settings.corsaPath,
+		...selection.options,
+		includeFixes: true
+	});
+	if (result.filename !== collected.filename) throw new Error("Vize returned diagnostics for another ESLint source");
+	const diagnostics = /* @__PURE__ */ new Map();
+	const offsets = [];
+	for (const diagnostic of result.diagnostics) {
+		if (!selection.names.includes(diagnostic.rule)) throw new Error(`Vize returned an unselected ESLint rule: ${diagnostic.rule}`);
+		if (byName.get(diagnostic.rule)?.fixable && !Object.hasOwn(diagnostic, "fix")) throw new Error("The Vize native binding does not expose ESLint text edits; update it");
+		const current = diagnostics.get(diagnostic.rule) ?? [];
+		current.push(diagnostic);
+		diagnostics.set(diagnostic.rule, current);
+		offsets.push(diagnostic.location.start.offset, diagnostic.location.end.offset);
+		for (const edit of diagnostic.fix?.edits ?? []) offsets.push(edit.start, edit.end);
+	}
+	collected.offsets = mapSourceOffsets(collected.source, offsets);
+	collected.diagnostics = diagnostics;
+}
+/** ESLint rules over the complete source supplied by the configured parser. */
+var eslint_default = eslintCompatPlugin(definePlugin({
+	meta: { name: "oxlint-plugin-vize" },
+	rules: Object.fromEntries(metadata.map((rule) => [rule.name, defineRule({
+		meta: {
+			...plugin_default.rules[rule.name].meta,
+			...rule.fixable ? { fixable: "code" } : {}
+		},
+		createOnce(context) {
+			let participated;
+			return {
+				before() {
+					participated = void 0;
+				},
+				after() {
+					if (participated) programs.delete(participated);
+					participated = void 0;
+				},
+				Program(program) {
+					if (!isPatinaFile(context.physicalFilename)) return;
+					const preset = getActivePreset(getVizeSettings(context));
+					if (preset !== "incremental" && rule.presets.length > 0 && !rule.presets.includes(preset)) return;
+					collect(context, program, rule.name);
+					participated = program;
+				},
+				"Program:exit"(program) {
+					if (participated !== program) return;
+					const collected = programs.get(program);
+					if (!collected?.options.has(rule.name)) return;
+					if (collected.source !== context.sourceCode.text || collected.sourceCode !== context.sourceCode || collected.filename !== context.physicalFilename || JSON.stringify(collected.settings) !== JSON.stringify(getVizeSettings(context))) throw new Error("Vize source changed before ESLint rule execution");
+					if (!collected.diagnostics) run(collected);
+					const sourceCode = context.sourceCode;
+					for (const diagnostic of collected.diagnostics.get(rule.name) ?? []) {
+						const start = collected.offsets.get(diagnostic.location.start.offset);
+						const end = collected.offsets.get(diagnostic.location.end.offset);
+						if (start > end) throw new Error("Vize returned a reversed diagnostic span");
+						const loc = {
+							start: sourceCode.getLocFromIndex(start),
+							end: sourceCode.getLocFromIndex(end)
+						};
+						if (loc.start.line !== diagnostic.location.start.line || loc.start.column + 1 !== diagnostic.location.start.column || loc.end.line !== diagnostic.location.end.line || loc.end.column + 1 !== diagnostic.location.end.column) throw new Error("Vize returned inconsistent ESLint location metadata");
+						const edits = diagnostic.fix ? mapTextEdits(diagnostic.fix.edits, collected.offsets) : void 0;
+						context.report({
+							loc,
+							message: formatPatinaMessage(diagnostic, {
+								hasMappedLocation: true,
+								blockLabel: null,
+								helpLevel: collected.settings.helpLevel ?? "full"
+							}),
+							...edits ? { fix(fixer) {
+								return edits.map((edit) => fixer.replaceTextRange(edit.range, edit.text));
+							} } : {}
+						});
+					}
+				}
+			};
+		}
+	})]))
+}));
+//#endregion
+export { configs, createVizeRuleConfig, eslint_default as default };

package/dist/index.d.mts

@@ -1,45 +1,8 @@
+import { a as VizeRuleConfigPreset, c as createVizeRuleConfig, i as VizeRuleConfigOptions, l as PatinaPreset, n as OxlintRuleEntry, o as VizeRuleConfigPresetInput, r as OxlintRuleSeverity, s as configs, t as OxlintRuleConfig, u as PatinaSettings } from "./configs-BuOTHAnm.mjs";
+
 //#region src/plugin.d.ts
 declare const _default: import("@oxlint/plugins").Plugin;
 //#endregion
-//#region src/model.d.ts
-type HelpLevel = "none" | "short" | "full";
-type PatinaPreset = "general-recommended" | "essential" | "ecosystem" | "incremental" | "opinionated" | "nuxt";
-interface PatinaSettings {
-  locale?: string;
-  helpLevel?: HelpLevel;
-  preset?: PatinaPreset;
-  typeAware?: boolean;
-  corsaPath?: string;
-  /** Rules to evaluate together. Oxlint's own rules still control reporting. */
-  rules?: readonly string[] | Record<string, unknown>;
-}
-//#endregion
-//#region src/configs.d.ts
-type OxlintRuleSeverity = "error" | "warn" | "off";
-type OxlintRuleEntry = OxlintRuleSeverity | [OxlintRuleSeverity, ...unknown[]];
-type OxlintRuleConfig = Record<string, OxlintRuleEntry>;
-type VizeRuleConfigPreset = Exclude<PatinaPreset, "incremental"> | "happy-path" | "all";
-type VizeRuleConfigPresetInput = VizeRuleConfigPreset | readonly VizeRuleConfigPreset[];
-interface VizeRuleConfigOptions {
-  includeTypeAware?: boolean;
-  preset?: VizeRuleConfigPresetInput;
-  presets?: readonly VizeRuleConfigPreset[];
-}
-declare function createVizeRuleConfig(options?: VizeRuleConfigOptions): OxlintRuleConfig;
-declare const configs: {
-  readonly all: OxlintRuleConfig;
-  readonly ecosystem: OxlintRuleConfig;
-  readonly ecosystemWithTypeAware: OxlintRuleConfig;
-  readonly essential: OxlintRuleConfig;
-  readonly happyPath: OxlintRuleConfig;
-  readonly happyPathWithTypeAware: OxlintRuleConfig;
-  readonly nuxt: OxlintRuleConfig;
-  readonly opinionated: OxlintRuleConfig;
-  readonly opinionatedWithTypeAware: OxlintRuleConfig;
-  readonly recommended: OxlintRuleConfig;
-  readonly recommendedWithTypeAware: OxlintRuleConfig;
-};
-//#endregion
 //#region src/vite-plus.d.ts
 /**
  * Bare specifier Oxlint uses to load this bridge as a JS plugin.