prettier-plugin-bootstrap 0.2.1 → 0.3.1

package/dist/index.mjs

@@ -1,282 +1,4 @@
-//#region src/class-order.ts
-const BREAKPOINTS = [
-	"sm",
-	"md",
-	"lg",
-	"xl",
-	"xxl"
-];
-const RESPONSIVE_RE = new RegExp(`^(.+?)-(${BREAKPOINTS.join("|")})-(.+)$`);
-const CLASS_ORDER = [
-	"container-fluid",
-	"container-sm",
-	"container-md",
-	"container-lg",
-	"container-xl",
-	"container-xxl",
-	"container",
-	"row",
-	"row-cols-",
-	"col-auto",
-	"col-1",
-	"col-2",
-	"col-3",
-	"col-4",
-	"col-5",
-	"col-6",
-	"col-7",
-	"col-8",
-	"col-9",
-	"col-10",
-	"col-11",
-	"col-12",
-	"col",
-	"offset-",
-	"g-",
-	"gx-",
-	"gy-",
-	"h1",
-	"h2",
-	"h3",
-	"h4",
-	"h5",
-	"h6",
-	"lead",
-	"display-",
-	"list-unstyled",
-	"list-inline",
-	"list-inline-item",
-	"initialism",
-	"blockquote",
-	"blockquote-footer",
-	"img-fluid",
-	"img-thumbnail",
-	"figure",
-	"figure-img",
-	"figure-caption",
-	"table",
-	"table-",
-	"caption-top",
-	"form-label",
-	"col-form-label",
-	"form-text",
-	"form-control",
-	"form-control-",
-	"form-select",
-	"form-select-",
-	"form-check",
-	"form-check-",
-	"form-switch",
-	"form-floating",
-	"form-range",
-	"input-group",
-	"input-group-",
-	"valid-feedback",
-	"valid-tooltip",
-	"invalid-feedback",
-	"invalid-tooltip",
-	"was-validated",
-	"btn",
-	"btn-",
-	"btn-close",
-	"btn-close-",
-	"fade",
-	"collapse",
-	"collapsing",
-	"show",
-	"dropdown",
-	"dropdown-",
-	"dropup",
-	"dropend",
-	"dropstart",
-	"btn-group",
-	"btn-group-",
-	"btn-toolbar",
-	"nav",
-	"nav-",
-	"tab-content",
-	"tab-pane",
-	"navbar",
-	"navbar-",
-	"card",
-	"card-",
-	"accordion",
-	"accordion-",
-	"breadcrumb",
-	"breadcrumb-item",
-	"pagination",
-	"pagination-",
-	"page-item",
-	"page-link",
-	"badge",
-	"alert",
-	"alert-",
-	"progress",
-	"progress-",
-	"progress-bar",
-	"progress-bar-",
-	"list-group",
-	"list-group-",
-	"toast",
-	"toast-",
-	"modal",
-	"modal-",
-	"tooltip",
-	"tooltip-",
-	"popover",
-	"popover-",
-	"carousel",
-	"carousel-",
-	"spinner-border",
-	"spinner-border-",
-	"spinner-grow",
-	"spinner-grow-",
-	"offcanvas",
-	"offcanvas-",
-	"placeholder",
-	"placeholder-",
-	"clearfix",
-	"link-",
-	"icon-link",
-	"icon-link-",
-	"ratio",
-	"ratio-",
-	"fixed-top",
-	"fixed-bottom",
-	"sticky-top",
-	"sticky-bottom",
-	"hstack",
-	"vstack",
-	"stretched-link",
-	"text-truncate",
-	"vr",
-	"visually-hidden",
-	"visually-hidden-focusable",
-	"align-",
-	"float-",
-	"object-fit-",
-	"opacity-",
-	"overflow-",
-	"d-",
-	"shadow",
-	"shadow-",
-	"focus-ring",
-	"focus-ring-",
-	"position-",
-	"top-",
-	"bottom-",
-	"start-",
-	"end-",
-	"translate-middle",
-	"translate-middle-",
-	"border",
-	"border-",
-	"w-",
-	"mw-",
-	"vw-",
-	"min-vw-",
-	"h-",
-	"mh-",
-	"vh-",
-	"min-vh-",
-	"flex-",
-	"justify-content-",
-	"align-items-",
-	"align-content-",
-	"align-self-",
-	"order-",
-	"m-",
-	"mx-",
-	"my-",
-	"mt-",
-	"me-",
-	"mb-",
-	"ms-",
-	"p-",
-	"px-",
-	"py-",
-	"pt-",
-	"pe-",
-	"pb-",
-	"ps-",
-	"gap-",
-	"row-gap-",
-	"column-gap-",
-	"font-monospace",
-	"fs-",
-	"fst-",
-	"fw-",
-	"lh-",
-	"text-decoration-",
-	"text-",
-	"text-opacity-",
-	"link-opacity-",
-	"link-offset-",
-	"link-underline",
-	"link-underline-",
-	"bg-",
-	"bg-opacity-",
-	"bg-gradient",
-	"user-select-",
-	"pe-none",
-	"pe-auto",
-	"rounded",
-	"rounded-",
-	"visible",
-	"invisible",
-	"z-"
-];
-function buildOrderMap() {
-	const map = /* @__PURE__ */ new Map();
-	for (const [index, prefix] of CLASS_ORDER.entries()) map.set(prefix, index);
-	return map;
-}
-const ORDER_MAP = buildOrderMap();
-function classKey(className) {
-	let base = className;
-	let breakpointIdx = 0;
-	const match = className.match(RESPONSIVE_RE);
-	if (match) {
-		base = `${match[1]}-${match[3]}`;
-		breakpointIdx = BREAKPOINTS.indexOf(match[2]) + 1;
-	}
-	let bestIdx = -1;
-	let bestLen = 0;
-	for (const [prefix, idx] of ORDER_MAP) if (base === prefix || prefix.endsWith("-") && base.startsWith(prefix)) {
-		if (prefix.length > bestLen) {
-			bestLen = prefix.length;
-			bestIdx = idx;
-		}
-	}
-	return [bestIdx === -1 ? Infinity : bestIdx, breakpointIdx];
-}
-function sortClasses(classes) {
-	const annotated = classes.map((cls, i) => ({
-		cls,
-		key: classKey(cls),
-		orig: i
-	}));
-	annotated.sort((a, b) => {
-		if (a.key[0] !== b.key[0]) return a.key[0] - b.key[0];
-		if (a.key[1] !== b.key[1]) return a.key[1] - b.key[1];
-		return a.orig - b.orig;
-	});
-	return annotated.map((entry) => entry.cls);
-}
-//#endregion
-//#region src/sorting.ts
-function sortClassString(value) {
-	if (!value || typeof value !== "string") return value;
-	const trimmed = value.trim();
-	if (!trimmed) return value;
-	const classes = trimmed.split(/\s+/);
-	if (classes.length <= 1) return value;
-	const sorted = sortClasses(classes);
-	const leadingWs = value.match(/^\s*/)[0];
-	const trailingWs = value.match(/\s*$/)[0];
-	return `${leadingWs}${sorted.join(" ")}${trailingWs}`;
-}
-//#endregion
+import { a as sortClasses, i as classKey, n as BREAKPOINTS, r as CLASS_ORDER, t as sortClassString } from "./sorting-BAmBKBim.mjs";
 //#region src/traversal.ts
 const AST_KEYS = [
 	"program",
@@ -319,10 +41,10 @@ function walk(node, visitor) {
 		}
 	}
 }
-function sortStringNode(node) {
+function sortStringNode(node, sortOptions) {
 	if (!node) return;
 	if (node.type === "StringLiteral") {
-		const sorted = sortClassString(node.value);
+		const sorted = sortClassString(node.value, sortOptions);
 		node.value = sorted;
 		if (node.extra) {
 			node.extra.rawValue = sorted;
@@ -331,7 +53,7 @@ function sortStringNode(node) {
 		return;
 	}
 	if (node.type === "Literal" && typeof node.value === "string") {
-		const sorted = sortClassString(node.value);
+		const sorted = sortClassString(node.value, sortOptions);
 		node.value = sorted;
 		if (node.raw) {
 			const quote = node.raw[0];
@@ -341,41 +63,41 @@ function sortStringNode(node) {
 	}
 	if (node.type === "TemplateLiteral" && (!node.expressions || node.expressions.length === 0)) {
 		for (const quasi of node.quasis) if (quasi.value && typeof quasi.value.raw === "string") {
-			const sorted = sortClassString(quasi.value.raw);
+			const sorted = sortClassString(quasi.value.raw, sortOptions);
 			quasi.value.raw = sorted;
 			quasi.value.cooked = sorted;
 		}
 	}
 }
-function processHtmlAst(ast, targetAttrs, _targetFunctions) {
+function processHtmlAst(ast, attrMatcher, _targetFunctions, sortOptions) {
+	const matchAttr = typeof attrMatcher === "function" ? attrMatcher : (name) => attrMatcher.includes(name);
 	walk(ast, (node) => {
 		if (node.attrs && Array.isArray(node.attrs)) {
-			for (const attr of node.attrs) if (targetAttrs.includes(attr.name) && typeof attr.value === "string") attr.value = sortClassString(attr.value);
+			for (const attr of node.attrs) if (matchAttr(attr.name) && typeof attr.value === "string") attr.value = sortClassString(attr.value, sortOptions);
 		}
-		if (node.attributes && Array.isArray(node.attributes)) for (const attr of node.attributes) {
-			const name = attr.name || attr.key && attr.key.value;
-			if (targetAttrs.includes(name) && attr.value) {
+		if (node.attributes && Array.isArray(node.attributes)) {
+			for (const attr of node.attributes) if (matchAttr(attr.name || attr.key && attr.key.value) && attr.value) {
 				if (typeof attr.value === "string") {
 					if (attr.kind && attr.kind !== "quoted") continue;
 					if (attr.value.includes("${")) continue;
-					attr.value = sortClassString(attr.value);
+					attr.value = sortClassString(attr.value, sortOptions);
 				} else if (attr.value && typeof attr.value.value === "string") {
 					if (attr.value.value.includes("${")) continue;
-					attr.value.value = sortClassString(attr.value.value);
+					attr.value.value = sortClassString(attr.value.value, sortOptions);
 				}
 			}
 		}
 	});
 	return ast;
 }
-function processJsxAst(ast, targetAttrs, targetFunctions = []) {
+function processJsxAst(ast, attrMatcher, targetFunctions = [], sortOptions) {
+	const matchAttr = typeof attrMatcher === "function" ? attrMatcher : (name) => attrMatcher.includes(name);
 	const functionSet = new Set(targetFunctions);
 	walk(ast, (node) => {
 		if (node.type === "JSXAttribute" || node.type === "JSXSpreadAttribute") {
-			const name = node.name && (node.name.name || node.name.value);
-			if (targetAttrs.includes(name) && node.value) {
+			if (matchAttr(node.name && (node.name.name || node.name.value)) && node.value) {
 				if (node.value.type === "StringLiteral" || node.value.type === "Literal") {
-					const sorted = sortClassString(node.value.value);
+					const sorted = sortClassString(node.value.value, sortOptions);
 					node.value.value = sorted;
 					if (node.value.extra) {
 						node.value.extra.rawValue = sorted;
@@ -390,7 +112,7 @@ function processJsxAst(ast, targetAttrs, targetFunctions = []) {
 		}
 		if (node.type === "CallExpression" && functionSet.size > 0) {
 			const callee = node.callee;
-			if (callee && callee.type === "Identifier" && functionSet.has(callee.name)) for (const arg of node.arguments || []) sortStringNode(arg);
+			if (callee && callee.type === "Identifier" && functionSet.has(callee.name)) for (const arg of node.arguments || []) sortStringNode(arg, sortOptions);
 		}
 	});
 	return ast;
@@ -401,15 +123,16 @@ function walkSvelte(node, visitor) {
 	if (node.fragment && Array.isArray(node.fragment.nodes)) for (const child of node.fragment.nodes) walkSvelte(child, visitor);
 	if (Array.isArray(node.children)) for (const child of node.children) walkSvelte(child, visitor);
 }
-function processSvelteAst(ast, targetAttrs, _targetFunctions) {
+function processSvelteAst(ast, attrMatcher, _targetFunctions, sortOptions) {
+	const matchAttr = typeof attrMatcher === "function" ? attrMatcher : (name) => attrMatcher.includes(name);
 	walkSvelte(ast, (node) => {
 		if (!node.attributes || !Array.isArray(node.attributes)) return;
 		for (const attr of node.attributes) {
 			if (attr.type !== "Attribute") continue;
-			if (!targetAttrs.includes(attr.name)) continue;
+			if (!matchAttr(attr.name)) continue;
 			if (Array.isArray(attr.value)) {
 				for (const item of attr.value) if (item.type === "Text" && typeof item.data === "string") {
-					const sorted = sortClassString(item.data);
+					const sorted = sortClassString(item.data, sortOptions);
 					item.data = sorted;
 					if (typeof item.raw === "string") item.raw = sorted;
 				}
@@ -421,6 +144,7 @@ function processSvelteAst(ast, targetAttrs, _targetFunctions) {
 //#endregion
 //#region src/index.ts
 const DEFAULT_ATTRIBUTES = ["class", "className"];
+const IGNORE_RE = /(?:<!--\s*prettier-bootstrap-ignore\s*-->|\/\/\s*prettier-bootstrap-ignore|\/\*\s*prettier-bootstrap-ignore\s*\*\/)/;
 const options = {
 	bootstrapAttributes: {
 		type: "string",
@@ -435,8 +159,36 @@ const options = {
 		default: [{ value: [] }],
 		category: "Bootstrap",
 		description: "Function names whose arguments are Bootstrap class lists (e.g. clsx, classNames)."
+	},
+	bootstrapPreserveWhitespace: {
+		type: "boolean",
+		default: false,
+		category: "Bootstrap",
+		description: "Preserve original whitespace between classes instead of normalizing to single spaces."
+	},
+	bootstrapPreserveDuplicates: {
+		type: "boolean",
+		default: true,
+		category: "Bootstrap",
+		description: "Keep duplicate class names. Set to false to remove duplicates."
+	},
+	bootstrapVersion: {
+		type: "int",
+		default: 5,
+		category: "Bootstrap",
+		description: "Bootstrap version (for future version-specific sorting rules)."
 	}
 };
+function buildAttrMatcher(allAttrs) {
+	const plainAttrs = [];
+	const regexAttrs = [];
+	for (const attr of allAttrs) {
+		const m = attr.match(/^\/(.+)\/([gimsuy]*)$/);
+		if (m) regexAttrs.push(new RegExp(m[1], m[2]));
+		else plainAttrs.push(attr);
+	}
+	return (name) => plainAttrs.includes(name) || regexAttrs.some((re) => re.test(name));
+}
 function createParserWrapper(parserName, processAst, astFormat) {
 	const wrapper = {
 		astFormat,
@@ -463,7 +215,15 @@ function createParserWrapper(parserName, processAst, astFormat) {
 			if (!originalParser) throw new Error(`prettier-plugin-bootstrap: could not find the "${parserName}" parser. Make sure Prettier and the relevant parser plugin are installed.`);
 			if (originalParser.locStart) wrapper.locStart = originalParser.locStart;
 			if (originalParser.locEnd) wrapper.locEnd = originalParser.locEnd;
-			return processAst(await originalParser.parse(text, options), [...DEFAULT_ATTRIBUTES, ...options.bootstrapAttributes || []], options.bootstrapFunctions || []);
+			if (originalParser.astFormat) wrapper.astFormat = originalParser.astFormat;
+			const ast = await originalParser.parse(text, options);
+			if (IGNORE_RE.test(text.slice(0, 1500))) return ast;
+			const targetAttrs = [...DEFAULT_ATTRIBUTES, ...options.bootstrapAttributes || []];
+			const targetFunctions = options.bootstrapFunctions || [];
+			return processAst(ast, buildAttrMatcher(targetAttrs), targetFunctions, {
+				preserveWhitespace: options.bootstrapPreserveWhitespace ?? false,
+				preserveDuplicates: options.bootstrapPreserveDuplicates ?? true
+			});
 		}
 	};
 	return wrapper;
@@ -481,4 +241,4 @@ const parsers = {
 	svelte: createParserWrapper("svelte", processSvelteAst, "svelte-ast")
 };
 //#endregion
-export { BREAKPOINTS, CLASS_ORDER, classKey, options, parsers, sortClasses };
+export { BREAKPOINTS, CLASS_ORDER, buildAttrMatcher, classKey, options, parsers, sortClasses };

package/dist/sorter.cjs

@@ -0,0 +1,15 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_sorting = require("./sorting-B-0731KP.cjs");
+//#region src/sorter.ts
+function createSorter(options) {
+	return {
+		sort: (classString) => require_sorting.sortClassString(classString, options),
+		sortClasses: (classes) => {
+			return require_sorting.sortClasses(options?.preserveDuplicates === false ? classes.filter((c, i) => classes.indexOf(c) === i) : classes);
+		}
+	};
+}
+//#endregion
+exports.createSorter = createSorter;
+exports.sortClassString = require_sorting.sortClassString;
+exports.sortClasses = require_sorting.sortClasses;

package/dist/sorter.d.cts

@@ -0,0 +1,13 @@
+import { i as sortClasses, o as SortOptions } from "./class-order-UKlp_Ej7.cjs";
+
+//#region src/sorting.d.ts
+declare function sortClassString(value: string, options?: SortOptions): string;
+//#endregion
+//#region src/sorter.d.ts
+interface Sorter {
+  sort(classString: string): string;
+  sortClasses(classes: string[]): string[];
+}
+declare function createSorter(options?: SortOptions): Sorter;
+//#endregion
+export { type SortOptions, Sorter, createSorter, sortClassString, sortClasses };

package/dist/sorter.d.mts

@@ -0,0 +1,13 @@
+import { i as sortClasses, o as SortOptions } from "./class-order-BYtmS-1R.mjs";
+
+//#region src/sorting.d.ts
+declare function sortClassString(value: string, options?: SortOptions): string;
+//#endregion
+//#region src/sorter.d.ts
+interface Sorter {
+  sort(classString: string): string;
+  sortClasses(classes: string[]): string[];
+}
+declare function createSorter(options?: SortOptions): Sorter;
+//#endregion
+export { type SortOptions, Sorter, createSorter, sortClassString, sortClasses };

package/dist/sorter.d.ts

@@ -0,0 +1,10 @@
+import { sortClasses } from './class-order';
+import { sortClassString } from './sorting';
+import type { SortOptions } from './types';
+export interface Sorter {
+    sort(classString: string): string;
+    sortClasses(classes: string[]): string[];
+}
+export declare function createSorter(options?: SortOptions): Sorter;
+export { sortClasses, sortClassString };
+export type { SortOptions };

package/dist/sorter.mjs

@@ -0,0 +1,12 @@
+import { a as sortClasses, t as sortClassString } from "./sorting-BAmBKBim.mjs";
+//#region src/sorter.ts
+function createSorter(options) {
+	return {
+		sort: (classString) => sortClassString(classString, options),
+		sortClasses: (classes) => {
+			return sortClasses(options?.preserveDuplicates === false ? classes.filter((c, i) => classes.indexOf(c) === i) : classes);
+		}
+	};
+}
+//#endregion
+export { createSorter, sortClassString, sortClasses };