Repository Public
1import Foundation2import SheetCore34/// One sort level; `column` is the zero-based offset inside the sorted range.5public struct SortColumn: Sendable, Hashable, Codable {6 public var column: Int7 public var ascending: Bool8 /// Text compares case-insensitively unless set (then uppercase sorts after lowercase on ties, as Excel does).9 public var caseSensitive: Bool10 public init(column: Int, ascending: Bool = true, caseSensitive: Bool = false) {11 self.column = column; self.ascending = ascending; self.caseSensitive = caseSensitive12 }13}1415/// Multi-level sort: the first key is the primary one.16public struct SortSpec: Sendable, Hashable, Codable {17 public var keys: [SortColumn]18 public init(_ keys: [SortColumn]) { self.keys = keys }1920 /// The same keys as `CalcEngine.sort` expects them (absolute sheet columns); case sensitivity is not carried over.21 public func engineKeys(range: RangeRef) -> [SortKey] {22 keys.map { SortKey(column: range.c0 + $0.column, ascending: $0.ascending) }23 }24}2526extension TableOps {27 /// Order of one key. Ascending: numbers (by value), then text (alphabetical), then FALSE < TRUE,28 /// then errors; descending reverses that. Blank cells always sort last.29 private static func order(_ a: Value, _ b: Value, _ key: SortColumn) -> Int {30 let ra = AuditRuleSupport.sortRank(a), rb = AuditRuleSupport.sortRank(b)31 if ra == 4 || rb == 4 { return ra == rb ? 0 : (ra == 4 ? 1 : -1) }32 var c: Int33 if ra != rb {34 c = ra < rb ? -1 : 135 } else {36 switch (a, b) {37 case (.text(let x), .text(let y)) where key.caseSensitive:38 let r = x.compare(y, options: [.caseInsensitive])39 if r != .orderedSame { c = r == .orderedAscending ? -1 : 1 }40 else { c = x == y ? 0 : (x > y ? -1 : 1) } // "a" before "A"41 case (.error(let x), .error(let y)): c = x.typeCode < y.typeCode ? -1 : (x.typeCode > y.typeCode ? 1 : 0)42 default: c = compareValues(a, b)43 }44 }45 return key.ascending ? c : -c46 }4748 /// The rows of `range` (sheet row indexes) in sorted order. The sort is stable: rows that compare49 /// equal on every key keep their original order. `range` must not include header or totals rows.50 public static func sortedRowOrder(sheet: Sheet, range: RangeRef, spec: SortSpec) -> [Int] {51 let keys = spec.keys.filter { $0.column >= 0 && $0.column < range.cols }52 let rows = Array(range.r0...range.r1)53 guard !keys.isEmpty else { return rows }54 let values: [[Value]] = rows.map { r in keys.map { sheet.value(r, range.c0 + $0.column) } }55 let idx = rows.indices.sorted { i, j in56 for (k, key) in keys.enumerated() {57 let c = order(values[i][k], values[j][k], key)58 if c != 0 { return c < 0 }59 }60 return i < j61 }62 return idx.map { rows[$0] }63 }6465 /// True when the rows are already in the order the spec asks for.66 public static func isSorted(sheet: Sheet, range: RangeRef, spec: SortSpec) -> Bool {67 sortedRowOrder(sheet: sheet, range: range, spec: spec) == Array(range.r0...range.r1)68 }6970 /// Rows of `range` that repeat an earlier row on the given columns (offsets inside the range; nil =71 /// all columns), in ascending order — the rows "Remove Duplicates" deletes; the first occurrence is kept.72 /// Text compares case-insensitively, numbers by value; a number and its text form are different values.73 public static func duplicateRows(sheet: Sheet, range: RangeRef, columns: [Int]? = nil) -> [Int] {74 let cols = (columns ?? Array(0..<range.cols)).filter { $0 >= 0 && $0 < range.cols }75 guard !cols.isEmpty else { return [] }76 var seen = Set<[String]>()77 var out = [Int]()78 for r in range.r0...range.r1 {79 let key = cols.map { c -> String in80 let v = sheet.value(r, range.c0 + c)81 if let k = AuditRuleSupport.key(v) { return k }82 if case .error(let e) = v { return "e" + e.rawValue }83 return ""84 }85 if !seen.insert(key).inserted { out.append(r) }86 }87 return out88 }89}90