Function prepareSortOrderUpdate

src/bases/sortOrderUtils.ts:562–694

(
	targetTaskPath: string,
	above: boolean,
	groupKey: string | null,
	groupByProperty: string | null,
	draggedPath: string,
	plugin: TaskNotesPlugin,
	options: SortOrderComputationOptions = {}
)

 * Prepare a sort-order update plan without writing any files yet.
 */
export async function prepareSortOrderUpdate(
	targetTaskPath: string,
	above: boolean,
	groupKey: string | null,
	groupByProperty: string | null,
	draggedPath: string,
	plugin: TaskNotesPlugin,
	options: SortOrderComputationOptions = {}
): Promise<SortOrderPlan> {
	const columnTasks = getGroupTasks(groupKey, groupByProperty, plugin, options).filter(
		(task) => task.path !== draggedPath
	);
	const orderedTasks = getVisibleOrderedTasks(columnTasks, options.visibleTaskPaths, draggedPath);
	const sortDirection = inferSortDirection(orderedTasks);

	if (columnTasks.length === 0) {
		return {
			sortOrder: middleRank().toString(),
			additionalWrites: [],
			reason: "boundary",
		};
	}

	const targetIndex = orderedTasks.findIndex((task) => task.path === targetTaskPath);
	if (targetIndex === -1) {
		const lastRankedTask = [...orderedTasks].reverse().find((task) => hasValidSortRank(task));
		const lastRank = lastRankedTask ? tryParseSortRank(lastRankedTask.sortOrder) : null;
		if (lastRank && !shouldRebalanceRank(lastRank)) {
			const sortOrder = rankAfterInDisplay(lastRank, sortDirection).toString();
			if (isCandidateInDisplayPosition(sortOrder, lastRank.toString(), null, sortDirection)) {
				return {
					sortOrder,
					additionalWrites: [],
					reason: "boundary",
				};
			}
		}

		if (orderedTasks.length > 0) {
			return createRebalancePlan(orderedTasks, orderedTasks.length - 1, false, sortDirection);
		}

		return {
			sortOrder: middleRank().toString(),
			additionalWrites: [],
			reason: "boundary",
		};
	}

	const targetTask = orderedTasks[targetIndex];
	const previousTask = targetIndex > 0 ? orderedTasks[targetIndex - 1] : null;
	const nextTask = targetIndex < orderedTasks.length - 1 ? orderedTasks[targetIndex + 1] : null;
	const targetRank = tryParseSortRank(targetTask.sortOrder);
	const previousRank = previousTask ? tryParseSortRank(previousTask.sortOrder) : null;
	const nextRank = nextTask ? tryParseSortRank(nextTask.sortOrder) : null;

	if (!targetRank) {
		return createRebalancePlan(orderedTasks, targetIndex, above, sortDirection);