prettier-plugin-wolfram 0.7.13 → 0.7.14

package/package.json

@@ -1,11 +1,15 @@
 {
 	"name": "prettier-plugin-wolfram",
-	"version": "0.7.13",
+	"version": "0.7.14",
 	"description": "Prettier plugin for Wolfram Language using tree-sitter",
 	"license": "MIT",
 	"repository": {
 		"type": "git",
-		"url": "git://github.com/ToneAr/prettier-plugin-wolfram.git"
+		"url": "https://github.com/ToneAr/prettier-plugin-wolfram.git"
+	},
+	"homepage": "https://github.com/ToneAr/prettier-plugin-wolfram#readme",
+	"bugs": {
+		"url": "https://github.com/ToneAr/prettier-plugin-wolfram/issues"
 	},
 	"keywords": [
 		"prettier",
@@ -55,8 +59,5 @@
 	},
 	"workspaces": [
 		"vscode-extension"
-	],
-	"engines": {
-		"vscode": "^1.105.0"
-	}
+	]
 }

package/src/options.js

@@ -15,6 +15,9 @@ function wolframOptionDefinition(definition) {
 	return {
 		type: definition.type,
 		category: "Wolfram",
+		...(hasOwn(definition, "exception")
+			? { exception: definition.exception }
+			: {}),
 		...(hasOwn(definition, "default")
 			? { default: definition.default }
 			: {}),
@@ -22,42 +25,61 @@ function wolframOptionDefinition(definition) {
 	};
 }
 
+function isBlankLineRange(value) {
+	return (
+		isPlainObject(value) &&
+		Number.isInteger(value.min) &&
+		Number.isInteger(value.max) &&
+		value.min >= 0 &&
+		value.max >= value.min
+	);
+}
+
+function blankLineRangeOption(defaultValue, description) {
+	return {
+		type: "int",
+		...(defaultValue == null ? {} : { default: defaultValue }),
+		exception: (value) =>
+			(Number.isInteger(value) && value >= 0) || isBlankLineRange(value),
+		description,
+	};
+}
+
 export const wolframOptions = {
 	newlinesBetweenDefinitions: {
-		type: "int",
-		default: 1,
-		minimum: 0,
+		...blankLineRangeOption(
+			{ min: 1, max: 1 },
+			"Allowed blank lines between adjacent definitions.",
+		),
 		legacyName: "wolframNewlinesBetweenDefinitions",
-		description: "Blank lines inserted between adjacent definitions.",
 	},
 	newlinesBetweenSetDefinitions: {
-		type: "int",
-		minimum: 0,
+		...blankLineRangeOption(
+			null,
+			"Allowed blank lines between adjacent Set-family definitions. Inherits newlinesBetweenDefinitions when unset.",
+		),
 		legacyName: "wolframNewlinesBetweenSetDefinitions",
-		description:
-			"Blank lines inserted between adjacent Set-family definitions. Inherits newlinesBetweenDefinitions when unset.",
 	},
 	newlinesBetweenSetDelayedDefinitions: {
-		type: "int",
-		minimum: 0,
+		...blankLineRangeOption(
+			null,
+			"Allowed blank lines between adjacent SetDelayed-family definitions. Inherits newlinesBetweenDefinitions when unset.",
+		),
 		legacyName: "wolframNewlinesBetweenSetDelayedDefinitions",
-		description:
-			"Blank lines inserted between adjacent SetDelayed-family definitions. Inherits newlinesBetweenDefinitions when unset.",
 	},
 	newlinesBetweenSetAndSetDelayedDefinitions: {
-		type: "int",
-		minimum: 0,
+		...blankLineRangeOption(
+			null,
+			"Allowed blank lines between mixed Set-family and SetDelayed-family definitions. Inherits newlinesBetweenDefinitions when unset.",
+		),
 		legacyName: "wolframNewlinesBetweenSetAndSetDelayedDefinitions",
-		description:
-			"Blank lines inserted between mixed Set-family and SetDelayed-family definitions. Inherits newlinesBetweenDefinitions when unset.",
 	},
 	newlinesBetweenSameNameDefinitions: {
-		type: "int",
-		default: 0,
-		minimum: 0,
+		...blankLineRangeOption(
+			{ min: 0, max: 0 },
+			"Allowed blank lines between adjacent definitions that belong to the same symbol.",
+		),
 		legacyName: "wolframNewlinesBetweenSameNameDefinitions",
-		description:
-			"Blank lines inserted between adjacent definitions that belong to the same symbol.",
 	},
 	maxBlankLinesBetweenCode: {
 		type: "int",

package/src/utils/codeSpacing.js

@@ -35,6 +35,27 @@ export function nonNegativeIntegerOption(value, fallback) {
 	return Math.max(0, Math.floor(numeric));
 }
 
+function blankLineRangeOption(value, fallback) {
+	if (value == null) return fallback;
+	if (typeof value === "object" && !Array.isArray(value)) {
+		const min = nonNegativeIntegerOption(value.min, fallback.min);
+		const max = nonNegativeIntegerOption(value.max, fallback.max);
+		return { min, max: Math.max(min, max) };
+	}
+
+	const exact = nonNegativeIntegerOption(value, fallback.min);
+	return { min: exact, max: exact };
+}
+
+function exactBlankLineRange(value) {
+	return { min: value, max: value };
+}
+
+function blankLinesFromRange(observedBlankLines, range) {
+	const observed = nonNegativeIntegerOption(observedBlankLines, 0);
+	return Math.min(range.max, Math.max(range.min, observed));
+}
+
 export function maxBlankLinesBetweenCode(options = {}) {
 	options = normalizeWolframOptions(options);
 	return nonNegativeIntegerOption(
@@ -44,47 +65,72 @@ export function maxBlankLinesBetweenCode(options = {}) {
 }
 
 export function blankLinesBetweenDefinitions(options = {}) {
+	const range = blankLineRangeBetweenDefinitions(options);
+	return range.min;
+}
+
+function blankLineRangeBetweenDefinitions(options = {}) {
 	options = normalizeWolframOptions(options);
-	return nonNegativeIntegerOption(
+	return blankLineRangeOption(
 		options.wolframNewlinesBetweenDefinitions,
-		DEFAULT_BLANK_LINES_BETWEEN_DEFINITIONS,
+		exactBlankLineRange(DEFAULT_BLANK_LINES_BETWEEN_DEFINITIONS),
 	);
 }
 
-function optionalBlankLinesOption(value, fallback) {
+function optionalBlankLineRangeOption(value, fallback) {
 	if (value == null) return fallback;
-	return nonNegativeIntegerOption(value, fallback);
+	return blankLineRangeOption(value, fallback);
 }
 
 export function blankLinesBetweenSetDefinitions(options = {}) {
+	const range = blankLineRangeBetweenSetDefinitions(options);
+	return range.min;
+}
+
+function blankLineRangeBetweenSetDefinitions(options = {}) {
 	options = normalizeWolframOptions(options);
-	return optionalBlankLinesOption(
+	return optionalBlankLineRangeOption(
 		options.wolframNewlinesBetweenSetDefinitions,
-		blankLinesBetweenDefinitions(options),
+		blankLineRangeBetweenDefinitions(options),
 	);
 }
 
 export function blankLinesBetweenSetDelayedDefinitions(options = {}) {
+	const range = blankLineRangeBetweenSetDelayedDefinitions(options);
+	return range.min;
+}
+
+function blankLineRangeBetweenSetDelayedDefinitions(options = {}) {
 	options = normalizeWolframOptions(options);
-	return optionalBlankLinesOption(
+	return optionalBlankLineRangeOption(
 		options.wolframNewlinesBetweenSetDelayedDefinitions,
-		blankLinesBetweenDefinitions(options),
+		blankLineRangeBetweenDefinitions(options),
 	);
 }
 
 export function blankLinesBetweenSetAndSetDelayedDefinitions(options = {}) {
+	const range = blankLineRangeBetweenSetAndSetDelayedDefinitions(options);
+	return range.min;
+}
+
+function blankLineRangeBetweenSetAndSetDelayedDefinitions(options = {}) {
 	options = normalizeWolframOptions(options);
-	return optionalBlankLinesOption(
+	return optionalBlankLineRangeOption(
 		options.wolframNewlinesBetweenSetAndSetDelayedDefinitions,
-		blankLinesBetweenDefinitions(options),
+		blankLineRangeBetweenDefinitions(options),
 	);
 }
 
 export function blankLinesBetweenSameNameDefinitions(options = {}) {
+	const range = blankLineRangeBetweenSameNameDefinitions(options);
+	return range.min;
+}
+
+function blankLineRangeBetweenSameNameDefinitions(options = {}) {
 	options = normalizeWolframOptions(options);
-	return nonNegativeIntegerOption(
+	return blankLineRangeOption(
 		options.wolframNewlinesBetweenSameNameDefinitions,
-		DEFAULT_BLANK_LINES_BETWEEN_SAME_NAME_DEFINITIONS,
+		exactBlankLineRange(DEFAULT_BLANK_LINES_BETWEEN_SAME_NAME_DEFINITIONS),
 	);
 }
 
@@ -187,6 +233,48 @@ function blankLinesBetweenDeclarationKinds(
 	return null;
 }
 
+function blankLineRangeBetweenDeclarationKinds(
+	prevKind,
+	nextKind,
+	options,
+	{ requireSpecificOption = false } = {},
+) {
+	if (prevKind === "set" && nextKind === "set") {
+		if (
+			requireSpecificOption &&
+			options.wolframNewlinesBetweenSetDefinitions == null
+		) {
+			return null;
+		}
+		return blankLineRangeBetweenSetDefinitions(options);
+	}
+
+	if (prevKind === "setDelayed" && nextKind === "setDelayed") {
+		if (
+			requireSpecificOption &&
+			options.wolframNewlinesBetweenSetDelayedDefinitions == null
+		) {
+			return null;
+		}
+		return blankLineRangeBetweenSetDelayedDefinitions(options);
+	}
+
+	if (
+		(prevKind === "set" && nextKind === "setDelayed") ||
+		(prevKind === "setDelayed" && nextKind === "set")
+	) {
+		if (
+			requireSpecificOption &&
+			options.wolframNewlinesBetweenSetAndSetDelayedDefinitions == null
+		) {
+			return null;
+		}
+		return blankLineRangeBetweenSetAndSetDelayedDefinitions(options);
+	}
+
+	return null;
+}
+
 function blankLinesBetweenDeclarationNodes(
 	prevNode,
 	nextNode,
@@ -201,6 +289,20 @@ function blankLinesBetweenDeclarationNodes(
 	);
 }
 
+function blankLineRangeBetweenDeclarationNodes(
+	prevNode,
+	nextNode,
+	options,
+	requireSpecificOption = false,
+) {
+	return blankLineRangeBetweenDeclarationKinds(
+		declarationSpacingKind(prevNode),
+		declarationSpacingKind(nextNode),
+		options,
+		{ requireSpecificOption },
+	);
+}
+
 function firstSemanticChild(node) {
 	return semanticChildren(node)[0] ?? null;
 }
@@ -396,14 +498,17 @@ export function blankLinesForCodeGap(
 	if (topLevel && mode === "none") return 0;
 
 	if (hasSharedDefinitionSubject(prevNode, nextNode)) {
-		return blankLinesBetweenSameNameDefinitions(options);
+		return blankLinesFromRange(
+			observedBlankLines,
+			blankLineRangeBetweenSameNameDefinitions(options),
+		);
 	}
 
 	if (isDeclarationNode(prevNode) && isDeclarationNode(nextNode)) {
-		return (
-			blankLinesBetweenDeclarationNodes(prevNode, nextNode, options) ??
-			blankLinesBetweenDefinitions(options)
-		);
+		const range =
+			blankLineRangeBetweenDeclarationNodes(prevNode, nextNode, options) ??
+			blankLineRangeBetweenDefinitions(options);
+		return blankLinesFromRange(observedBlankLines, range);
 	}
 
 	const maxBlankLines = maxBlankLinesBetweenCode(options);