@codefast/cli 0.3.13-canary.3 → 0.3.13

package/dist/lib/arrange/domain/ast/collectors-tv.collector.mjs

@@ -0,0 +1,174 @@
+import "../constants.domain.mjs";
+import { forEachDomainChild, isDomainArrayLiteralExpression, isDomainCallExpression, isDomainObjectLiteralExpression, isDomainPropertyAssignment, isDomainSpreadElement, isDomainTailwindClassLiteral } from "./ast-node.model.mjs";
+import { buildKnownCnTvBindings, isCnOrTvIdentifier, propertyAssignmentNameText } from "./ast-helpers.helper.mjs";
+import { CN_APPLY_LITERAL_WALK_OPTS, collectUnconditionalTailwindLiteralsFromCnArguments, forEachStringLiteralInClassExpression, isUnsafeLiteralForCnStyleApplySplit } from "./collectors-cn.collector.mjs";
+import { tokenizeClassString } from "../tokenizer.util.mjs";
+//#region src/lib/arrange/domain/ast/collectors-tv.collector.ts
+function traverseTvObject(sourceFile, obj, visitor, depth = 0, knownBindings) {
+	if (depth > 12) return;
+	for (const prop of obj.properties) {
+		if (!isDomainPropertyAssignment(prop)) continue;
+		const init = prop.initializer;
+		if (isDomainTailwindClassLiteral(init)) visitor(init, sourceFile, void 0);
+		else if (isDomainArrayLiteralExpression(init)) for (const arrayElement of init.elements) {
+			if (isDomainSpreadElement(arrayElement)) continue;
+			if (isDomainTailwindClassLiteral(arrayElement)) visitor(arrayElement, sourceFile, void 0);
+			else if (isDomainCallExpression(arrayElement) && isCnOrTvIdentifier(arrayElement.expression, "cn", knownBindings)) for (const arg of arrayElement.arguments) forEachStringLiteralInClassExpression(arg, (lit) => {
+				visitor(lit, sourceFile, arrayElement);
+			});
+			else if (isDomainObjectLiteralExpression(arrayElement)) for (const objectProperty of arrayElement.properties) {
+				if (!isDomainPropertyAssignment(objectProperty)) continue;
+				const propName = propertyAssignmentNameText(objectProperty);
+				if (propName !== "className" && propName !== "class") continue;
+				const innerInit = objectProperty.initializer;
+				if (isDomainTailwindClassLiteral(innerInit)) visitor(innerInit, sourceFile, void 0);
+				else if (isDomainArrayLiteralExpression(innerInit)) for (const nestedArrayElement of innerInit.elements) {
+					if (isDomainSpreadElement(nestedArrayElement)) continue;
+					if (isDomainTailwindClassLiteral(nestedArrayElement)) visitor(nestedArrayElement, sourceFile, void 0);
+				}
+				else if (isDomainCallExpression(innerInit) && isCnOrTvIdentifier(innerInit.expression, "cn", knownBindings)) for (const arg of innerInit.arguments) forEachStringLiteralInClassExpression(arg, (lit) => {
+					visitor(lit, sourceFile, innerInit);
+				});
+			}
+		}
+		else if (isDomainObjectLiteralExpression(init)) traverseTvObject(sourceFile, init, visitor, depth + 1, knownBindings);
+		else if (isDomainCallExpression(init) && isCnOrTvIdentifier(init.expression, "cn", knownBindings)) for (const arg of init.arguments) forEachStringLiteralInClassExpression(arg, (lit) => {
+			visitor(lit, sourceFile, init);
+		});
+	}
+}
+function collectCnCallsInsideTv(sourceFile, obj, knownBindings, depth = 0) {
+	if (depth > 12) return [];
+	const calls = [];
+	for (const prop of obj.properties) {
+		if (!isDomainPropertyAssignment(prop)) continue;
+		const init = prop.initializer;
+		if (isDomainArrayLiteralExpression(init)) for (const arrayElement of init.elements) {
+			if (isDomainSpreadElement(arrayElement)) continue;
+			if (isDomainCallExpression(arrayElement) && isCnOrTvIdentifier(arrayElement.expression, "cn", knownBindings)) calls.push(arrayElement);
+			else if (isDomainObjectLiteralExpression(arrayElement)) for (const objectProperty of arrayElement.properties) {
+				if (!isDomainPropertyAssignment(objectProperty)) continue;
+				const propName = propertyAssignmentNameText(objectProperty);
+				if (propName !== "className" && propName !== "class") continue;
+				const innerInit = objectProperty.initializer;
+				if (isDomainCallExpression(innerInit) && isCnOrTvIdentifier(innerInit.expression, "cn", knownBindings)) calls.push(innerInit);
+			}
+		}
+		else if (isDomainObjectLiteralExpression(init)) calls.push(...collectCnCallsInsideTv(sourceFile, init, knownBindings, depth + 1));
+		else if (isDomainCallExpression(init) && isCnOrTvIdentifier(init.expression, "cn", knownBindings)) calls.push(init);
+	}
+	return calls;
+}
+function listAllCnCallsInsideTvInSourceFile(sourceFile, knownBindings) {
+	const calls = [];
+	const visitSubtree = (tsNode) => {
+		if (isDomainCallExpression(tsNode) && isCnOrTvIdentifier(tsNode.expression, "tv", knownBindings)) {
+			const arg0 = tsNode.arguments[0];
+			if (arg0 && isDomainObjectLiteralExpression(arg0)) calls.push(...collectCnCallsInsideTv(sourceFile, arg0, knownBindings, 0));
+		}
+		forEachDomainChild(tsNode, visitSubtree);
+	};
+	for (const stmt of sourceFile.statements) visitSubtree(stmt);
+	return calls;
+}
+function makeStringNode(nodes, sourceFile, isTvContext, cnCall) {
+	return {
+		nodes,
+		sf: sourceFile,
+		isTvContext,
+		cnCall,
+		get primaryClassLiteral() {
+			const first = this.nodes[0];
+			if (first === void 0) throw new Error("invariant: StringNode requires at least one class literal");
+			return first;
+		}
+	};
+}
+function slotClassString(stringNode) {
+	return stringNode.nodes.map((literal) => literal.text).join(" ");
+}
+function emitTvSlot(lits, sourceFile, cnCall, results, seenNodePos) {
+	if (lits.length === 0) return;
+	const firstLit = lits[0];
+	if (firstLit === void 0) return;
+	const firstPos = firstLit.pos;
+	if (seenNodePos.has(firstPos)) return;
+	seenNodePos.add(firstPos);
+	if (lits.reduce((accumulatedTokenCount, literal) => accumulatedTokenCount + tokenizeClassString(literal.text).length, 0) < 2) return;
+	results.push(makeStringNode(lits, sourceFile, true, cnCall));
+}
+function collectTvSlots(sourceFile, obj, knownBindings, results, seenNodePos, depth = 0) {
+	if (depth > 12) return;
+	for (const prop of obj.properties) {
+		if (!isDomainPropertyAssignment(prop)) continue;
+		const init = prop.initializer;
+		if (isDomainTailwindClassLiteral(init)) emitTvSlot([init], sourceFile, void 0, results, seenNodePos);
+		else if (isDomainArrayLiteralExpression(init)) {
+			const arrayPos = init.pos;
+			if (seenNodePos.has(arrayPos)) continue;
+			seenNodePos.add(arrayPos);
+			const staticLits = [];
+			for (const arrayElement of init.elements) {
+				if (isDomainSpreadElement(arrayElement)) continue;
+				if (isDomainTailwindClassLiteral(arrayElement)) staticLits.push(arrayElement);
+				else if (isDomainCallExpression(arrayElement) && isCnOrTvIdentifier(arrayElement.expression, "cn", knownBindings)) for (const arg of arrayElement.arguments) forEachStringLiteralInClassExpression(arg, (lit) => {
+					if (!isUnsafeLiteralForCnStyleApplySplit(lit)) staticLits.push(lit);
+				}, 0, CN_APPLY_LITERAL_WALK_OPTS);
+				else if (isDomainObjectLiteralExpression(arrayElement)) for (const objectProperty of arrayElement.properties) {
+					if (!isDomainPropertyAssignment(objectProperty)) continue;
+					const propName = propertyAssignmentNameText(objectProperty);
+					if (propName !== "className" && propName !== "class") continue;
+					const innerInit = objectProperty.initializer;
+					if (isDomainTailwindClassLiteral(innerInit)) emitTvSlot([innerInit], sourceFile, void 0, results, seenNodePos);
+					else if (isDomainArrayLiteralExpression(innerInit)) {
+						const innerLits = [];
+						for (const nestedArrayElement of innerInit.elements) if (!isDomainSpreadElement(nestedArrayElement) && isDomainTailwindClassLiteral(nestedArrayElement)) innerLits.push(nestedArrayElement);
+						emitTvSlot(innerLits, sourceFile, void 0, results, seenNodePos);
+					} else if (isDomainCallExpression(innerInit) && isCnOrTvIdentifier(innerInit.expression, "cn", knownBindings)) {
+						const cnLits = [];
+						for (const arg of innerInit.arguments) forEachStringLiteralInClassExpression(arg, (lit) => {
+							if (!isUnsafeLiteralForCnStyleApplySplit(lit)) cnLits.push(lit);
+						}, 0, CN_APPLY_LITERAL_WALK_OPTS);
+						emitTvSlot(cnLits, sourceFile, innerInit, results, seenNodePos);
+					}
+				}
+			}
+			if (staticLits.length > 0) emitTvSlot(staticLits, sourceFile, void 0, results, seenNodePos);
+		} else if (isDomainObjectLiteralExpression(init)) collectTvSlots(sourceFile, init, knownBindings, results, seenNodePos, depth + 1);
+		else if (isDomainCallExpression(init) && isCnOrTvIdentifier(init.expression, "cn", knownBindings)) {
+			const cnLits = [];
+			for (const arg of init.arguments) forEachStringLiteralInClassExpression(arg, (lit) => {
+				if (!isUnsafeLiteralForCnStyleApplySplit(lit)) cnLits.push(lit);
+			}, 0, CN_APPLY_LITERAL_WALK_OPTS);
+			emitTvSlot(cnLits, sourceFile, init, results, seenNodePos);
+		}
+	}
+}
+function collectGroupableStringNodes(sourceFile) {
+	const results = [];
+	const seenNodePos = /* @__PURE__ */ new Set();
+	const knownBindings = buildKnownCnTvBindings(sourceFile);
+	const visitTypeScriptSubtree = (tsNode) => {
+		if (isDomainCallExpression(tsNode)) {
+			if (isCnOrTvIdentifier(tsNode.expression, "cn", knownBindings)) {
+				const callPos = tsNode.pos;
+				if (seenNodePos.has(callPos)) {
+					forEachDomainChild(tsNode, visitTypeScriptSubtree);
+					return;
+				}
+				seenNodePos.add(callPos);
+				const staticLits = collectUnconditionalTailwindLiteralsFromCnArguments(tsNode.arguments);
+				const totalTokens = staticLits.reduce((accumulatedTokenCount, literal) => accumulatedTokenCount + tokenizeClassString(literal.text).length, 0);
+				if (staticLits.length > 0 && totalTokens >= 2) results.push(makeStringNode(staticLits, sourceFile, false, tsNode));
+			} else if (isCnOrTvIdentifier(tsNode.expression, "tv", knownBindings)) {
+				const arg0 = tsNode.arguments[0];
+				if (arg0 && isDomainObjectLiteralExpression(arg0)) collectTvSlots(sourceFile, arg0, knownBindings, results, seenNodePos);
+			}
+		}
+		forEachDomainChild(tsNode, visitTypeScriptSubtree);
+	};
+	for (const stmt of sourceFile.statements) visitTypeScriptSubtree(stmt);
+	return results;
+}
+//#endregion
+export { collectCnCallsInsideTv, collectGroupableStringNodes, collectTvSlots, emitTvSlot, listAllCnCallsInsideTvInSourceFile, makeStringNode, slotClassString, traverseTvObject };

package/dist/lib/arrange/domain/ast/targets.model.mjs

@@ -0,0 +1,110 @@
+import "../constants.domain.mjs";
+import { indentOfLineContaining } from "../../../shared/source-code/domain/text-edit.model.mjs";
+import { forEachDomainChild, isDomainArrayLiteralExpression, isDomainJsxAttribute, isDomainTailwindClassLiteral } from "./ast-node.model.mjs";
+import { isUnsafeLiteralForCnStyleApplySplit } from "./collectors-cn.collector.mjs";
+import { tokenizeClassString } from "../tokenizer.util.mjs";
+import { collectGroupableStringNodes, slotClassString } from "./collectors-tv.collector.mjs";
+import { areCnTailwindPartitionsEquivalent, suggestCnGroups, summarizeGroupBucketLabels } from "../grouping.domain.mjs";
+import { escapeTsStringLiteralContent, formatArray, formatJsxCnAttributeValue } from "../source-text-formatters.formatter.mjs";
+import { jsxClassNameStaticLiteral } from "./collectors-jsx.collector.mjs";
+//#region src/lib/arrange/domain/ast/targets.model.ts
+function targetReplaceStart(target) {
+	if (target.kind === "cnArg") return target.item.cnCall ? target.item.cnCall.pos : target.item.primaryClassLiteral.pos;
+	return target.valueNode.pos;
+}
+function collectLongJsxClassNameTargets(sourceFile) {
+	const results = [];
+	const visitTypeScriptSubtree = (tsNode) => {
+		if (isDomainJsxAttribute(tsNode)) {
+			const parsed = jsxClassNameStaticLiteral(tsNode);
+			if (parsed && tokenizeClassString(parsed.lit.text).length >= 2) results.push({
+				kind: "jsxClassName",
+				sf: sourceFile,
+				lit: parsed.lit,
+				valueNode: parsed.valueNode
+			});
+		}
+		forEachDomainChild(tsNode, visitTypeScriptSubtree);
+	};
+	for (const stmt of sourceFile.statements) visitTypeScriptSubtree(stmt);
+	return results;
+}
+function collectGroupTargets(sourceFile, filePath) {
+	const cnPart = collectGroupableStringNodes(sourceFile).map((stringNode) => ({
+		kind: "cnArg",
+		item: stringNode
+	}));
+	if (!filePath.endsWith(".tsx")) return cnPart;
+	return [...cnPart, ...collectLongJsxClassNameTargets(sourceFile)];
+}
+function formatCnCallReplacement(stringNode, sourceText, withClassName) {
+	const call = stringNode.cnCall;
+	if (call === void 0) throw new Error("formatCnCallReplacement requires a cn() call on the string node");
+	const baseIndent = indentOfLineContaining(sourceText, call.pos);
+	const argIndent = `${baseIndent}  `;
+	const dynamicArgTexts = [];
+	for (const arg of call.arguments) if (!(isDomainTailwindClassLiteral(arg) && !isUnsafeLiteralForCnStyleApplySplit(arg))) dynamicArgTexts.push(sourceText.slice(arg.pos, arg.end));
+	const pool = slotClassString(stringNode);
+	const groups = pool.trim() ? suggestCnGroups(pool) : [];
+	const allArgs = [];
+	if (groups.length > 1) for (const group of groups) allArgs.push(`${argIndent}"${escapeTsStringLiteralContent(group)}"`);
+	else if (groups.length === 1) {
+		const onlyGroup = groups[0];
+		if (onlyGroup === void 0) throw new Error("invariant: single cn group missing");
+		allArgs.push(`${argIndent}"${escapeTsStringLiteralContent(onlyGroup)}"`);
+	}
+	for (const dynamicArgumentSource of dynamicArgTexts) allArgs.push(`${argIndent}${dynamicArgumentSource}`);
+	if (withClassName) allArgs.push(`${argIndent}className`);
+	const commaAfterLastArg = allArgs.length > 1;
+	return `cn(\n${allArgs.map((argLine, lineIndex) => lineIndex < allArgs.length - 1 || commaAfterLastArg ? `${argLine},` : `${argLine}`).join("\n")}\n${baseIndent})`;
+}
+function planGroupEditForTarget(target, textAfterUnwrap, withClassName) {
+	if (target.kind === "jsxClassName") {
+		const groups = suggestCnGroups(target.lit.text);
+		if (groups.length <= 1) return;
+		const start = target.valueNode.pos;
+		return {
+			start,
+			end: target.valueNode.end,
+			replacement: formatJsxCnAttributeValue(groups, textAfterUnwrap, start),
+			bucketSummary: summarizeGroupBucketLabels(groups),
+			jsxCn: true,
+			lineSf: target.sf,
+			reportNode: target.lit,
+			label: "JSX className"
+		};
+	}
+	const groups = suggestCnGroups(slotClassString(target.item));
+	if (groups.length <= 1) return;
+	if (areCnTailwindPartitionsEquivalent(target.item.nodes.map((classLiteral) => classLiteral.text), groups)) return;
+	if (!target.item.cnCall) {
+		const anchorClassLiteral = target.item.primaryClassLiteral;
+		const parentArray = target.item.nodes.length > 1 && anchorClassLiteral.parent !== null && isDomainArrayLiteralExpression(anchorClassLiteral.parent) ? anchorClassLiteral.parent : null;
+		const start = parentArray ? parentArray.pos : anchorClassLiteral.pos;
+		const end = parentArray ? parentArray.end : anchorClassLiteral.end;
+		const baseIndent = indentOfLineContaining(textAfterUnwrap, start);
+		return {
+			start,
+			end,
+			replacement: formatArray(groups).split("\n").map((line, lineIndex) => lineIndex === 0 ? line : `${baseIndent}${line}`).join("\n"),
+			bucketSummary: summarizeGroupBucketLabels(groups),
+			jsxCn: false,
+			lineSf: target.item.sf,
+			reportNode: anchorClassLiteral,
+			label: target.item.isTvContext ? "tv" : "cn"
+		};
+	}
+	const call = target.item.cnCall;
+	return {
+		start: call.pos,
+		end: call.end,
+		replacement: formatCnCallReplacement(target.item, textAfterUnwrap, withClassName),
+		bucketSummary: summarizeGroupBucketLabels(groups),
+		jsxCn: false,
+		lineSf: target.item.sf,
+		reportNode: target.item.primaryClassLiteral,
+		label: target.item.isTvContext ? "tv" : "cn"
+	};
+}
+//#endregion
+export { collectGroupTargets, collectLongJsxClassNameTargets, formatCnCallReplacement, planGroupEditForTarget, targetReplaceStart };

package/dist/lib/arrange/domain/constants.domain.mjs

@@ -0,0 +1,154 @@
+//#region src/lib/arrange/domain/constants.domain.ts
+/** Analyze report: long literal threshold (token count). */ const LONG_STRING_TOKEN_THRESHOLD = 18;
+/**
+* Minimum token count for a string to be considered a candidate for grouping
+* in the apply/preview pipeline. Intentionally much lower than
+* {@link LONG_STRING_TOKEN_THRESHOLD} (analyze only).
+*/ const APPLY_MIN_TOKENS = 2;
+/**
+* Minimum tokens a group must have to stand alone before singleton-merging.
+* Set to 2 so single-token groups are not collapsed into unrelated buckets by the merger.
+*/ const MIN_GROUP_TOKENS = 2;
+/** Dynamic max groups clamp: base bound. */ const MAX_GROUPS_BASE = 4;
+/** Dynamic max groups clamp: upper cap. */ const MAX_GROUPS_CAP = 24;
+/**
+* Extra slots so a few state / aria groups do not force `capGroups` to merge
+* unrelated buckets (e.g. `bg-border` + `outline-hidden`).
+*/ const MAX_GROUPS_HEADROOM = 2;
+/** Maximum findings printed per category in the analyze report. */ const MAX_REPORT_LINES = 40;
+/** Maximum recursion depth when traversing `tv()` object literals. */ const MAX_OBJECT_DEPTH = 12;
+/** Maximum depth when peeling conditional / parens / arrays inside `cn(...)` args. */ const MAX_CLASS_EXPR_DEPTH = 12;
+/**
+* Maximum variant-stripping passes in {@link stripVariants}.
+* Real-world Tailwind stacks rarely exceed 4–5 segments (e.g. `@md/sidebar:group-hover:dark:focus-visible:`);
+* 12 is a conservative safety cap that prevents runaway loops on malformed input.
+*/ const MAX_STRIP_VARIANT_PASSES = 12;
+/**
+* Passed when optional `knownBindings` is missing — size 0 disables matching
+* for `cn` / `tv` identifier resolution.
+*/ const EMPTY_CN_TV_BINDINGS = /* @__PURE__ */ new Set();
+/**
+* Bucket sort order — **render pipeline** (lower → earlier in `cn()` output).
+*
+* Matches README: Existence → Position → Layout → Sizing → Spacing → Shape → Background
+* → Shadow → Typography → Composite → Motion → Starting → Behavior → State → Selector,
+* then `other` and `arbitrary` as sort tails for unknown utilities and arbitrary properties.
+*/ const BUCKET_ORDER = {
+	existence: 0,
+	position: 1,
+	layout: 2,
+	sizing: 3,
+	spacing: 4,
+	shape: 5,
+	background: 6,
+	shadow: 7,
+	typography: 8,
+	composite: 9,
+	motion: 10,
+	starting: 11,
+	behavior: 12,
+	state: 13,
+	selector: 14,
+	other: 15,
+	arbitrary: 16
+};
+/**
+* Compatible bucket **pairs** — two adjacent tokens whose buckets appear in the same
+* `Set` may stay in one `cn()` string chunk. Compatibility is **not transitive**: there is
+* no `{position, sizing}` pair, so `fixed inset-0` and `overflow-auto` become **separate**
+* literals unless **layout** tokens sit between them in sorted order; then
+* `position↔layout` and `layout↔sizing` each justify one hop and the whole “box in flow”
+* (place + tracks + scrollport) stays in one chunk — co-located because they jointly define
+* stacking and scroll behavior for the same surface.
+*/ const COMPATIBLE_BUCKET_SETS = [
+	new Set(["existence", "position"]),
+	new Set(["existence", "layout"]),
+	new Set(["position", "layout"]),
+	new Set(["layout", "sizing"]),
+	new Set(["shape", "shadow"]),
+	new Set(["background", "shadow"]),
+	new Set(["background", "typography"]),
+	new Set(["layout", "typography"]),
+	new Set(["sizing", "typography"]),
+	new Set(["motion", "behavior"]),
+	new Set(["motion", "starting"]),
+	new Set(["composite", "motion"]),
+	new Set(["sizing", "composite"]),
+	new Set(["sizing", "spacing"])
+];
+/**
+* Responsive / variant prefix — Tailwind v4 aware.
+*
+* v3: sm: md: … — v4: @sm:, @min-[600px]:, @[480px]:, named @md/sidebar:,
+* viewport md/sidebar:, min-[100px]: / max-[100px]:, …
+*/ const RESPONSIVE_PREFIX = /^(?:@(?:min|max)-\[[^\]]+\]:|@\[[^\]]+\]:|@(?:[a-z0-9]+(?:-[a-z0-9]+)*)(?:\/[a-z][a-z0-9-]*)?:|(?:max-|min-)?(?:sm|md|lg|xl|2xl|3xl)(?:\/[a-z][a-z0-9-]*)?:|(?:max-|min-)\[[^\]]+\]:)/;
+/** State variant stems — hoisted to module scope (not recreated per call). */ const STATE_PREFIXES = new Set([
+	"hover",
+	"focus",
+	"focus-within",
+	"focus-visible",
+	"active",
+	"visited",
+	"link",
+	"any-link",
+	"disabled",
+	"enabled",
+	"checked",
+	"indeterminate",
+	"required",
+	"optional",
+	"valid",
+	"invalid",
+	"in-range",
+	"out-of-range",
+	"read-only",
+	"read-write",
+	"placeholder-shown",
+	"default",
+	"autofill",
+	"open",
+	"closed",
+	"first",
+	"last",
+	"only",
+	"odd",
+	"even",
+	"first-of-type",
+	"last-of-type",
+	"only-of-type",
+	"first-child",
+	"last-child",
+	"only-child",
+	"empty",
+	"target",
+	"group",
+	"peer",
+	"aria",
+	"data",
+	"dark",
+	"light",
+	"supports",
+	"motion-reduce",
+	"motion-safe",
+	"print",
+	"screen",
+	"ltr",
+	"rtl",
+	"not",
+	"has",
+	"in",
+	"nth",
+	"file",
+	"selection",
+	"marker",
+	"placeholder",
+	"before",
+	"after",
+	"first-line",
+	"first-letter",
+	"backdrop",
+	"details-content",
+	"popover-open"
+]);
+//#endregion
+export { APPLY_MIN_TOKENS, BUCKET_ORDER, COMPATIBLE_BUCKET_SETS, EMPTY_CN_TV_BINDINGS, LONG_STRING_TOKEN_THRESHOLD, MAX_CLASS_EXPR_DEPTH, MAX_GROUPS_BASE, MAX_GROUPS_CAP, MAX_GROUPS_HEADROOM, MAX_OBJECT_DEPTH, MAX_REPORT_LINES, MAX_STRIP_VARIANT_PASSES, MIN_GROUP_TOKENS, RESPONSIVE_PREFIX, STATE_PREFIXES };

package/dist/lib/arrange/domain/errors.domain.mjs

@@ -0,0 +1,18 @@
+//#region src/lib/arrange/domain/errors.domain.ts
+/**
+* Structured errors for the arrange CLI library (throw from lib; handle exit in commands).
+*/ const ArrangeErrorCode = {
+	TARGET_NOT_FOUND: "TARGET_NOT_FOUND",
+	INVALID_INPUT: "INVALID_INPUT",
+	INTERNAL: "INTERNAL"
+};
+var ArrangeError = class extends Error {
+	code;
+	constructor(code, message, options) {
+		super(message, options);
+		this.name = "ArrangeError";
+		this.code = code;
+	}
+};
+//#endregion
+export { ArrangeError, ArrangeErrorCode };