open-grid 1.6.0 → 1.7.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (126) hide show
  1. package/CHANGELOG.md +62 -0
  2. package/dist/ExportProgressView-9Kt1SQxv.js +48 -0
  3. package/dist/ExportProgressView-B59uHIwt.cjs +48 -0
  4. package/dist/LcpMergeOrderer-BdUtV67j.js +114 -0
  5. package/dist/LcpMergeOrderer-C_ANVkGk.cjs +113 -0
  6. package/dist/OpenGrid-BUYQs1_w.cjs +9806 -0
  7. package/dist/OpenGrid-BmagF0yo.js +9819 -0
  8. package/dist/XlsxChannel-DOeHeP7h.cjs +95 -0
  9. package/dist/XlsxChannel-DdaiytFR.js +95 -0
  10. package/dist/XlsxWorkbookWriter-BTNtZ80J.js +199 -0
  11. package/dist/XlsxWorkbookWriter-_u5stfg4.cjs +198 -0
  12. package/dist/{index-Brnev66-.js → index-B9_g5Eg3.js} +2 -2
  13. package/dist/{index-B_e5BXnW.cjs → index-CnyumyPV.cjs} +2 -2
  14. package/dist/open-grid-a11y.cjs +216 -0
  15. package/dist/open-grid-a11y.js +219 -0
  16. package/dist/open-grid-base.css +9 -0
  17. package/dist/open-grid-header.css +6 -15
  18. package/dist/open-grid-react.cjs +1 -1
  19. package/dist/open-grid-react.js +1 -1
  20. package/dist/open-grid-vue.cjs +1 -1
  21. package/dist/open-grid-vue.js +1 -1
  22. package/dist/open-grid.cjs +5 -2
  23. package/dist/open-grid.js +6 -3
  24. package/dist/sinks-BWkWQexV.js +149 -0
  25. package/dist/sinks-DPK0VxYG.cjs +143 -0
  26. package/dist/types/a11y/index.d.ts +37 -0
  27. package/dist/types/core/CFRenderBridge.d.ts +5 -1
  28. package/dist/types/core/CellEditManager.d.ts +26 -2
  29. package/dist/types/core/CellEventHandler.d.ts +6 -2
  30. package/dist/types/core/ColumnLayout.d.ts +11 -3
  31. package/dist/types/core/DataLayer.d.ts +48 -1
  32. package/dist/types/core/DetailManager.d.ts +43 -2
  33. package/dist/types/core/ExportManager.d.ts +26 -6
  34. package/dist/types/core/FindBarManager.d.ts +6 -2
  35. package/dist/types/core/FlatRowModel.d.ts +69 -3
  36. package/dist/types/core/FooterManager.d.ts +43 -1
  37. package/dist/types/core/FormulaController.d.ts +4 -4
  38. package/dist/types/core/GridComposer.d.ts +11 -1
  39. package/dist/types/core/GridRenderer.d.ts +84 -19
  40. package/dist/types/core/GroupTreeManager.d.ts +6 -4
  41. package/dist/types/core/KeyboardManager.d.ts +3 -2
  42. package/dist/types/core/MergeEngine.d.ts +45 -5
  43. package/dist/types/core/MutationService.d.ts +14 -17
  44. package/dist/types/core/OpenGrid.d.ts +350 -12
  45. package/dist/types/core/OrgChart.d.ts +24 -0
  46. package/dist/types/core/RangeSelectionManager.d.ts +23 -2
  47. package/dist/types/core/RenderController.d.ts +126 -8
  48. package/dist/types/core/RowDragDrop.d.ts +2 -0
  49. package/dist/types/core/SortFilterManager.d.ts +18 -2
  50. package/dist/types/core/VirtualScroll.d.ts +12 -0
  51. package/dist/types/core/WorksheetManager.d.ts +2 -2
  52. package/dist/types/core/a11y/KeyboardInteractionModel.d.ts +321 -20
  53. package/dist/types/core/a11y/LiveRegionController.d.ts +229 -27
  54. package/dist/types/core/a11y/VisualEquivRegistry.d.ts +199 -14
  55. package/dist/types/core/appearance/TextureRegistry.d.ts +10 -0
  56. package/dist/types/core/cf/CFRule.d.ts +145 -22
  57. package/dist/types/core/coordinate/CellTextPolicy.d.ts +58 -0
  58. package/dist/types/core/coordinate/ColumnGeometry.d.ts +60 -0
  59. package/dist/types/core/coordinate/ColumnWindow.d.ts +40 -0
  60. package/dist/types/core/coordinate/ColumnWindowPolicy.d.ts +89 -0
  61. package/dist/types/core/coordinate/ExtraColumns.d.ts +39 -0
  62. package/dist/types/core/coordinate/RangeRectCalculator.d.ts +35 -0
  63. package/dist/types/core/coordinate/ViewportHeightJudge.d.ts +28 -0
  64. package/dist/types/core/coordinate/geometryPorts.d.ts +250 -0
  65. package/dist/types/core/coordinate/ports.d.ts +5 -0
  66. package/dist/types/core/domain/footer/FooterValues.d.ts +50 -0
  67. package/dist/types/core/domain/footer/ports.d.ts +31 -0
  68. package/dist/types/core/domain/render/RenderPlanner.d.ts +17 -0
  69. package/dist/types/core/domain/render/RenderRequest.d.ts +91 -0
  70. package/dist/types/core/domain/render/ports.d.ts +169 -0
  71. package/dist/types/core/domain/resize/ResizeGesture.d.ts +25 -0
  72. package/dist/types/core/domain/resize/ResizeHitZone.d.ts +23 -0
  73. package/dist/types/core/domain/resize/ports.d.ts +64 -0
  74. package/dist/types/core/domain/sort/ComparisonOrderer.d.ts +11 -0
  75. package/dist/types/core/domain/sort/LcpMergeOrderer.d.ts +15 -0
  76. package/dist/types/core/domain/sort/RankIndex.d.ts +74 -0
  77. package/dist/types/core/domain/sort/SortCostEstimate.d.ts +36 -0
  78. package/dist/types/core/domain/sort/SortKeyColumn.d.ts +89 -0
  79. package/dist/types/core/domain/sort/SortKeyStore.d.ts +34 -0
  80. package/dist/types/core/domain/sort/Sorter.d.ts +54 -0
  81. package/dist/types/core/domain/sort/SyncSortRunner.d.ts +9 -0
  82. package/dist/types/core/domain/sort/commonPrefix.d.ts +5 -0
  83. package/dist/types/core/domain/sort/ports.d.ts +140 -0
  84. package/dist/types/core/export/ExportProgressView.d.ts +28 -0
  85. package/dist/types/core/export/channels/XlsxChannel.d.ts +29 -0
  86. package/dist/types/core/export/channels/XlsxWorkbookWriter.d.ts +17 -0
  87. package/dist/types/core/export/index.d.ts +2 -0
  88. package/dist/types/core/export/sinks.d.ts +81 -0
  89. package/dist/types/core/host/archCheck.d.ts +16 -1
  90. package/dist/types/core/i18n/locales/en.d.ts +6 -0
  91. package/dist/types/core/i18n/locales/ko.d.ts +6 -0
  92. package/dist/types/core/i18n/types.d.ts +8 -0
  93. package/dist/types/core/render/FooterView.d.ts +121 -0
  94. package/dist/types/core/render/GeometryApplier.d.ts +55 -0
  95. package/dist/types/core/render/HorizontalReveal.d.ts +26 -0
  96. package/dist/types/core/render/RangeOverlayAdapter.d.ts +10 -0
  97. package/dist/types/core/render/RenderScheduler.d.ts +225 -0
  98. package/dist/types/core/render/ResizeSinkAdapter.d.ts +35 -0
  99. package/dist/types/core/render/ScrollFollower.d.ts +34 -0
  100. package/dist/types/core/render/ScrollObserver.d.ts +47 -0
  101. package/dist/types/core/render/ScrollbarGutter.d.ts +19 -0
  102. package/dist/types/core/render/body/BodyEventRouter.d.ts +58 -0
  103. package/dist/types/core/render/body/BodyRowSet.d.ts +28 -0
  104. package/dist/types/core/render/body/BodyView.d.ts +185 -0
  105. package/dist/types/core/render/body/CellLocator.d.ts +36 -0
  106. package/dist/types/core/render/body/CellRegistry.d.ts +24 -0
  107. package/dist/types/core/render/body/ColumnPaintPlan.d.ts +19 -0
  108. package/dist/types/core/render/body/ExtraCellPainters.d.ts +20 -0
  109. package/dist/types/core/render/body/rows/BodyRowContext.d.ts +138 -0
  110. package/dist/types/core/render/body/rows/DataRowPainter.d.ts +58 -0
  111. package/dist/types/core/render/body/rows/DetailRowPainter.d.ts +24 -0
  112. package/dist/types/core/render/body/rows/GroupRowPainter.d.ts +32 -0
  113. package/dist/types/core/render/body/rows/RowPainterTable.d.ts +24 -0
  114. package/dist/types/core/render/body/rows/WindowLayout.d.ts +38 -0
  115. package/dist/types/core/render/dom.d.ts +10 -0
  116. package/dist/types/core/render/header/HeaderSortIndicator.d.ts +39 -0
  117. package/dist/types/core/render/header/HeaderView.d.ts +84 -0
  118. package/dist/types/core/render/header/ResizeHandleBinder.d.ts +110 -0
  119. package/dist/types/core/render/ports.d.ts +218 -0
  120. package/dist/types/core/renderers/CellRenderer.d.ts +7 -0
  121. package/dist/types/core/types.d.ts +572 -22
  122. package/dist/types/index.d.ts +31 -1
  123. package/dist/types/vue/OpenGrid.vue.d.ts +2 -2
  124. package/package.json +8 -9
  125. package/dist/OpenGrid-DgZtbVD0.cjs +0 -7390
  126. package/dist/OpenGrid-E11B7Xa7.js +0 -7403
@@ -0,0 +1,23 @@
1
+ /**
2
+ * 경계에서 이 px 안쪽까지(양 끝 포함)를 손잡이로 친다.
3
+ *
4
+ * Points within this many px of a boundary (inclusive) count as the grip.
5
+ */
6
+ export declare const RESIZE_HIT_HALF_PX = 6;
7
+ /**
8
+ * 머리글 잎 칸 안의 한 점이 어느 컬럼의 손잡이에 드는지 판정한다(불변 값 — 칸마다 객체를 만들지 않으려고 그리드당 하나).
9
+ *
10
+ * Decides which column's grip a point inside a header leaf cell falls on (one immutable instance per grid).
11
+ */
12
+ export declare class ResizeHitZone {
13
+ private readonly _half;
14
+ constructor(_half?: number);
15
+ /**
16
+ * @param x 칸 왼쪽 끝에서 잰 점의 x(px) / x of the point from the cell's left edge
17
+ * @param width 칸 폭(px) / cell width
18
+ * @param leaf 칸의 잎 컬럼 번호 / leaf column index of the cell
19
+ * @param canResize 그 컬럼을 끌 수 있나(손잡이가 있는 잎) / whether a column is resizable
20
+ * @returns 끌 컬럼 번호, 손잡이가 아니면 −1 / column to resize, or −1
21
+ */
22
+ columnFor(x: number, width: number, leaf: number, canResize: (ci: number) => boolean): number;
23
+ }
@@ -0,0 +1,64 @@
1
+ /**
2
+ * 상태: idle → pressed → dragging → (release|cancel|lose) → swallowing → idle.
3
+ * swallowing: 놓은 뒤(또는 손잡이 구역에서 누른 뒤) 따라오는 click 한 번을 정렬로 넘기지 않는 상태.
4
+ */
5
+ export type ResizePhase = 'idle' | 'pressed' | 'dragging' | 'swallowing';
6
+ /**
7
+ * 지금은 {min: 40, max: Infinity} 고정 — 지금 너비 조절의 `Math.max(40, …)` 그대로(col.minWidth 를 안 읽음).
8
+ * col.minWidth/maxWidth 반영은 동작을 바꾸는 일이라 따로 한다.
9
+ */
10
+ export interface ResizeBounds {
11
+ readonly min: number;
12
+ readonly max: number;
13
+ }
14
+ export interface ResizeResult {
15
+ readonly ci: number;
16
+ readonly width: number;
17
+ }
18
+ /**
19
+ * 너비 조절 한 번의 상태와 폭 계산의 유일한 주인. DOM·시계 없음(jsdom 없이 시험).
20
+ * 불변: dragging 밖에서 move 는 null · move·release·lose 가 내는 폭은 늘 [min, max](cancel 은 시작 폭 — 한계 밖일 수 있음) · 한 제스처에 commit(release|lose) 은 많아야 한 번 ·
21
+ * 시작 폭은 기하에서 받는다(DOM offsetWidth 안 읽음).
22
+ * 입력은 「x 좌표」라 마우스·펜·터치가 같은 길을 쓰고, 나중에 키보드 조절도 같은 상태 기계에 들어온다.
23
+ * 입력 규칙(DOM 쪽 ResizeHandleBinder 가 지킴): 포인터 이벤트가 있으면 포인터만 듣고,
24
+ * 진행 중 pointerId 가 있으면 합성 mousedown/mousemove/mouseup 은 무시한다(누름 두 번 방지).
25
+ * 포인터 이벤트가 없는 환경(jsdom)은 마우스 이벤트로 같은 상태 기계를 몬다. 손잡이에 touch-action 은 두지 않는다(터치 끌기는 발주자 결정 항목 — 기본 머리글 DOM 이 바뀜).
26
+ * / Sole owner of one resize gesture's state and width math; no DOM, no clock.
27
+ */
28
+ export interface IResizeGesture {
29
+ readonly phase: ResizePhase;
30
+ readonly column: number;
31
+ press(ci: number, startWidth: number, clientX: number, bounds: ResizeBounds): void;
32
+ /** 새 폭(바뀌었을 때만), 아니면 null. */
33
+ move(clientX: number): number | null;
34
+ /** 놓음 → 확정할 폭. 그 뒤 phase = swallowing. 폭이 안 바뀌었으면 null(정렬은 그래도 안 부름). */
35
+ release(clientX: number): ResizeResult | null;
36
+ /** Esc → 시작 폭으로 되돌릴 값(한계로 자르지 않음). */
37
+ cancel(): ResizeResult | null;
38
+ /** 포인터 잃음·창 blur → 그 순간 폭으로 확정(Esc 만 되돌린다). */
39
+ lose(): ResizeResult | null;
40
+ /** 머리글 click 처리기가 묻는다: 이 click 을 삼켜야 하나(삼키면 phase = idle — 단 끄는 중이면 끌기를 잇는다). */
41
+ consumeClick(): boolean;
42
+ /**
43
+ * 「놓음」(swallowing)을 끝낸다 — click 이 끝내 안 오는 경우(창 밖에서 놓음·포인터 잃음)에 상태가 남지 않게.
44
+ * binder 가 놓은 뒤 **다음 rAF** 에 부른다(click 은 pointerup/mouseup 과 같은 작업 안에서 그 전에 온다). 다음 press 도 swallowing 을 끝낸다.
45
+ * pressed 에서 cancel/lose → null 을 돌려주고 idle(폭 변화 0, 삼킬 click 없음). dragging 에서 cancel/lose → 결과를 돌려주고 swallowing.
46
+ */
47
+ expireSwallow(): void;
48
+ }
49
+ /**
50
+ * 놓을 때 바깥에 알리는 포트. 다시 그리기를 부르지 않는다.
51
+ * 구현은 OpenGrid 가 아니라 GridComposer 가 만드는 작은 어댑터 `ResizeSinkAdapter` — OpenGrid 에 책임을 더 얹지 않는다.
52
+ * / Port notified on release; never triggers a redraw.
53
+ */
54
+ export interface IResizeSink {
55
+ boundsOf(ci: number): ResizeBounds;
56
+ /** 사용자 폭 기억(_userWidths 저장 — 지금 OpenGrid._handleColResize 의 저장부와 같은 뜻). */
57
+ commit(ci: number, width: number): void;
58
+ /**
59
+ * 줄바꿈 머리글이 있을 때만 true → **놓을 때 한 번** remeasureHeader. 끄는 프레임마다의 머리글 높이 맞춤은
60
+ * RenderScheduler 가 IHeaderView.height() 로 한다.
61
+ */
62
+ needsHeaderRemeasure(): boolean;
63
+ remeasureHeader(): void;
64
+ }
@@ -0,0 +1,11 @@
1
+ import { ISortKeyColumn, ISortOrderer, SortDir } from './ports.js';
2
+ /**
3
+ * 안정 비교 정렬. 어떤 키 열이든 받는 기본 순서 매기기다(다른 전략이 거절할 때 늘 남는 자리).
4
+ *
5
+ * Stable comparison sort; the default orderer that accepts every key column.
6
+ */
7
+ export declare class ComparisonOrderer implements ISortOrderer {
8
+ readonly id = "comparison";
9
+ accepts(_keys: readonly ISortKeyColumn[], _rowCount: number): boolean;
10
+ order(start: readonly number[], keys: readonly ISortKeyColumn[], dirs: readonly SortDir[]): Int32Array;
11
+ }
@@ -0,0 +1,15 @@
1
+ import { ISortKeyColumn, ISortOrderer, SortDir } from './ports.js';
2
+ export { SortCostEstimate } from './SortCostEstimate.js';
3
+ /**
4
+ * 문자열 키 하나로 정렬하는 안정 병합 정렬. 이웃 공통 머리말 배열(H)을 들고 아래→위로 병합한다.
5
+ *
6
+ * Stable merge sort on a single string key; merges bottom-up while carrying the neighbour LCP array.
7
+ */
8
+ export declare class LcpMergeOrderer implements ISortOrderer {
9
+ readonly id = "lcpMerge";
10
+ /** 문자열 키 열 하나일 때만(숫자·섞인 열·등수·여러 키는 비교 정렬). */
11
+ accepts(keys: readonly ISortKeyColumn[], _rowCount: number): boolean;
12
+ order(start: readonly number[], keys: readonly ISortKeyColumn[], dirs: readonly SortDir[]): Int32Array;
13
+ /** text 의 자리 번호를 정렬해 돌려준다(같은 글은 자리 순서). / Sorts positions of text; ties keep position order. */
14
+ private _sort;
15
+ }
@@ -0,0 +1,74 @@
1
+ import { IRankIndex, ISortKeyColumn, SortDir } from './ports.js';
2
+ /**
3
+ * 한 컬럼에서 읽어 둔 원시값과 「읽은 행」 표시. 낡음 검사의 유일한 기준이다.
4
+ *
5
+ * The primitives read from one column plus which rows were read; the sole baseline for staleness checks.
6
+ */
7
+ export declare class ValueSnapshot {
8
+ readonly field: string;
9
+ readonly values: readonly unknown[];
10
+ private readonly _covered;
11
+ /**
12
+ * @param field 필드 이름 / field name
13
+ * @param values 행 번호 자리의 값(읽은 행만 의미가 있음) / values by row index (meaningful for read rows only)
14
+ * @param read 값을 읽은 행 번호들 / row indexes that were read
15
+ */
16
+ constructor(field: string, values: readonly unknown[], read: ArrayLike<number>);
17
+ /** 행 번호들이 모두 읽은 행인가. / Whether every given row was read. */
18
+ covers(rows: ArrayLike<number>): boolean;
19
+ /**
20
+ * O(n) 낡음 검사: 행 수가 같고, 볼 행(start — 생략하면 읽은 행 전부)이 모두 읽은 행이며,
21
+ * 그 자리의 지금 값이 보관값과 === 인가. 행마다 이 필드를 한 번만 읽는다.
22
+ *
23
+ * O(n) freshness: same row count, every row to check (start, or all read rows when omitted) was read,
24
+ * and its current value is === the stored one. Reads this field once per row.
25
+ */
26
+ isFreshFor(rows: readonly unknown[], start?: ArrayLike<number>): boolean;
27
+ }
28
+ /**
29
+ * 등수 보관(값 객체 — 만든 뒤 바뀌지 않는다). 같은 값 = 같은 등수, 작은 값 = 작은 등수.
30
+ * 등수를 매긴 행 밖의 행은 등수가 없으므로, 정렬할 행이 하나라도 그 밖이면 낡은 것으로 본다.
31
+ *
32
+ * Immutable rank holder: equal values share a rank, smaller values get smaller ranks. Rows outside the
33
+ * ranked set have no rank, so any row to be sorted outside it makes the index stale.
34
+ */
35
+ export declare class RankIndex implements IRankIndex {
36
+ readonly field: string;
37
+ private readonly _ranks;
38
+ private readonly _snapshot;
39
+ private constructor();
40
+ /**
41
+ * 정렬이 끝난 순서에서 등수를 매긴다 — 이웃끼리 한 번씩만 비교하므로 O(n).
42
+ * sorted 는 key 의 오름(dir 'asc')·내림(그 밖 — 옛 고리처럼 'asc' 가 아니면 뒤집힌 것) 순서로 놓인 행 번호여야 한다
43
+ * (같은 값끼리는 붙어 있다). values 는 key 를 만들 때 읽은 원시값(행 번호 자리) — 낡음 검사의 기준이다.
44
+ *
45
+ * Ranks rows from a finished sort order with one comparison per neighbour (O(n)). sorted must list row
46
+ * indexes in ascending ('asc') or descending (anything else) key order; values are the primitives read when
47
+ * key was built, indexed by row, and are the baseline for staleness checks.
48
+ */
49
+ static fromSorted(field: string, key: ISortKeyColumn, sorted: ArrayLike<number>, dir: SortDir | undefined, values: readonly unknown[]): RankIndex;
50
+ compare(i: number, j: number): number;
51
+ /** 행 번호들이 모두 등수를 가졌나. / Whether every given row has a rank. */
52
+ covers(rows: ArrayLike<number>): boolean;
53
+ /**
54
+ * O(n) 낡음 검사 — 행 수 · 등수 가진 행 · 값 === (ValueSnapshot.isFreshFor 와 같음).
55
+ * O(n) staleness check — row count, ranked rows, values === (same as ValueSnapshot.isFreshFor).
56
+ */
57
+ isFreshFor(rows: readonly unknown[], start?: ArrayLike<number>): boolean;
58
+ }
59
+ /**
60
+ * 등수로 비교하는 키 열. 등수가 원래 키 열과 같은 차례를 지키므로 순서 매기기 결과도 같다.
61
+ * 비교가 정수라 글자 키를 내주지 않는다(머리말 기억 정렬이 필요 없다).
62
+ *
63
+ * Key column that compares by rank; ranks keep the original column's order, so orderings are identical.
64
+ * Comparisons are integers, so no string key is exposed (prefix-aware orderers are unnecessary).
65
+ */
66
+ export declare class RankedKeyColumn implements ISortKeyColumn {
67
+ private readonly _index;
68
+ readonly kind: "ranked";
69
+ readonly cacheable = true;
70
+ constructor(_index: RankIndex);
71
+ get field(): string;
72
+ compare(i: number, j: number): number;
73
+ stringKeyAt(_i: number): string | null;
74
+ }
@@ -0,0 +1,36 @@
1
+ import { ISortCostEstimate, ISortKeyColumn, ISortOrderer } from './ports.js';
2
+ /**
3
+ * 정렬 시간 어림(값 객체). 만들 때 한 번 셈하고 바뀌지 않는다.
4
+ *
5
+ * Immutable sort-time estimate, computed once at construction.
6
+ */
7
+ export declare class SortCostEstimate implements ISortCostEstimate {
8
+ readonly expectedMs: number;
9
+ private constructor();
10
+ /**
11
+ * @param rowCount 정렬할 행 수 / rows to sort
12
+ * @param keys 키 열(우선순위 순) / key columns in priority order
13
+ * @param fresh 보관된 등수를 쓸 수 있는가 / whether retained ranks can be used
14
+ */
15
+ static of(rowCount: number, keys: readonly ISortKeyColumn[], fresh: boolean): SortCostEstimate;
16
+ prefersSlicing(thresholdMs?: number): boolean;
17
+ /**
18
+ * 문자열 키의 「표본을 정렬한 뒤 이웃끼리의 평균 공통 머리말 길이」. 무작위 두 글만 견주면 긴 머리말 묶음이
19
+ * 여럿인 자료(묶음마다 다른 머리말)를 놓치므로, 표본을 먼저 정렬해 이웃을 본다.
20
+ * 표본은 출발 순서를 1,024 칸으로 나눠 칸마다 하나(칸 안 자리는 고정 씨앗) — 같은 자료면 늘 같은 값이고,
21
+ * 키를 읽는 횟수는 행 수와 무관하게 많아야 1,024 번이다. 빈 값은 건너뛴다.
22
+ *
23
+ * Mean common prefix of sorted-sample neighbours for a string key. Comparing random pairs misses data with
24
+ * several long-prefix groups, so the sample is sorted first. One row per 1,024 equal slices of the start order
25
+ * (fixed-seed offset inside each slice): deterministic, and at most 1,024 key reads whatever the row count.
26
+ */
27
+ static meanCommonPrefix(key: ISortKeyColumn, start: readonly number[]): number;
28
+ /**
29
+ * 순서 매기기 고르기: 받아 주는 것들 가운데 머리말 기억 정렬은 행이 표본 수 이상이고 표본 이웃 평균 공통 머리말이
30
+ * 문턱(64자)을 넘을 때만, 아니면 그 밖의 첫 전략. 후보 목록의 차례와 무관하게 같은 것을 고른다.
31
+ *
32
+ * Orderer choice: the prefix-aware orderer only when there are at least sample-size rows and the sampled mean
33
+ * neighbour prefix exceeds 64; otherwise the first other accepting orderer. Independent of candidate order.
34
+ */
35
+ static pickOrderer(orderers: readonly ISortOrderer[], keys: readonly ISortKeyColumn[], start: readonly number[]): ISortOrderer;
36
+ }
@@ -0,0 +1,89 @@
1
+ import { ISortKeyColumn, SortComparator, SortDir } from './ports.js';
2
+ /**
3
+ * 기본 단일 키 비교 — 그리드가 처음부터 써 온 규칙 그대로다.
4
+ * null/undefined 가 먼저, 둘 다 숫자면 뺄셈, 나머지는 String() 으로 바꿔 UTF-16 코드 단위 순.
5
+ * 모듈 상수로 둔 까닭: 덮어쓴 비교자가 이것과 같은 함수인지(===) 보고 빠른 길을 고를 수 있게 하려는 것.
6
+ *
7
+ * The built-in single-key comparison, exactly as the grid has always done it: null/undefined first,
8
+ * numeric subtraction when both are numbers, otherwise String() compared by UTF-16 code units.
9
+ * It is a module constant so a resolved override can be recognised by identity (===).
10
+ */
11
+ export declare const DEFAULT_SORT_COMPARATOR: SortComparator;
12
+ /**
13
+ * 키 열의 뼈대. 어떤 구현을 쓸지는 build 한 곳에서만 고른다(부르는 쪽이 종류를 조건문으로 가르지 않게).
14
+ *
15
+ * Base of the key-column strategies; build() is the single place that picks an implementation,
16
+ * so callers never branch on the kind themselves.
17
+ */
18
+ export declare abstract class SortKeyColumn implements ISortKeyColumn {
19
+ abstract readonly field: string;
20
+ abstract readonly kind: ISortKeyColumn['kind'];
21
+ abstract readonly cacheable: boolean;
22
+ abstract compare(i: number, j: number): number;
23
+ abstract stringKeyAt(i: number): string | null;
24
+ /**
25
+ * 한 컬럼의 키 열을 만든다. values[i] = 모델 행 i 의 값(한 번만 읽어 넘긴 것).
26
+ * dir 은 비교자에 그대로 넘기는 정렬 방향이다 — 옛 비교 고리가 사용자 비교자에 (a, b, field, dir) 를
27
+ * 넘겼으므로 덮어쓴 비교자가 dir 을 읽어도 같은 값을 받게 한다. 비교 결과 자체는 늘 오름차순 뜻이고,
28
+ * 내림차순 뒤집기는 순서 매기기 쪽이 한다. 방향이 빠진 정렬 목록이면 undefined 를 그대로 넘긴다(옛 고리와 같음 —
29
+ * 순서는 「asc 가 아니면 뒤집음」이라 내림차순인데, 기본값을 채우면 비교자만 「asc」라고 듣게 된다).
30
+ *
31
+ * Builds the key column for one field; values[i] is model row i's value, read once.
32
+ * dir is forwarded to the comparator unchanged, because the legacy loop passed (a, b, field, dir)
33
+ * and an override may read it. The result of compare() is always in ascending sense; the orderer flips it.
34
+ * A missing dir is passed on as undefined, as before — no default is filled in.
35
+ */
36
+ static build(field: string, values: readonly unknown[], cmp: SortComparator, isDefaultCmp: boolean, dir?: SortDir): SortKeyColumn;
37
+ }
38
+ /**
39
+ * 옛 비교자를 그대로 부르는 키 열. 섞인 열·사용자 비교자·비교가 일관되지 않는 값(NaN 등)이 오는 자리.
40
+ * 비교마다 행에서 값을 다시 꺼내지 않도록 값 배열만 들고, 비교는 그 배열의 두 칸을 비교자에 넘긴다.
41
+ *
42
+ * Key column that calls the legacy comparator as-is — used for mixed columns, user comparators and
43
+ * values the comparator does not order consistently (NaN …). It holds the extracted value array so
44
+ * a comparison never goes back to the row objects.
45
+ */
46
+ export declare class GeneralKeyColumn extends SortKeyColumn {
47
+ readonly field: string;
48
+ private readonly _values;
49
+ private readonly _cmp;
50
+ private readonly _dir;
51
+ readonly kind: "general";
52
+ readonly cacheable: boolean;
53
+ constructor(field: string, _values: readonly unknown[], _cmp: SortComparator, _dir: SortDir | undefined);
54
+ compare(i: number, j: number): number;
55
+ stringKeyAt(_i: number): string | null;
56
+ }
57
+ /**
58
+ * 숫자만 든 열. 키를 Float64Array 에, 빈 값(null/undefined)을 따로 표시해 두고 비교는 두 칸 뺄셈뿐이다.
59
+ * 옛 비교자와 같은 값을 돌려준다: 빈 값끼리 0, 빈 값이 앞, 나머지는 a - b(−0 과 0 은 같음).
60
+ *
61
+ * Numbers-only column: keys in a Float64Array plus an empty-value mark; compare() returns exactly what the
62
+ * legacy comparator returned (empties equal and first, otherwise a - b, so −0 equals 0).
63
+ */
64
+ export declare class NumberKeyColumn extends SortKeyColumn {
65
+ readonly field: string;
66
+ readonly kind: "number";
67
+ readonly cacheable = true;
68
+ private readonly _keys;
69
+ private readonly _empty;
70
+ constructor(field: string, values: readonly unknown[]);
71
+ compare(i: number, j: number): number;
72
+ stringKeyAt(_i: number): string | null;
73
+ }
74
+ /**
75
+ * 글자만 든 열. String() 을 행마다 한 번만 불러 키를 들고, 비교는 UTF-16 코드 단위 사전순(옛 비교자와 같음).
76
+ * 빈 값(null/undefined)은 키 null 로 두고 앞에 온다. 긴 공통 머리말 정렬이 쓰도록 키를 그대로 내준다.
77
+ *
78
+ * Strings-only column: String() runs once per row; compare() is UTF-16 code-unit order like the legacy
79
+ * comparator, with empties (key null) first. stringKeyAt() exposes the key for prefix-aware orderers.
80
+ */
81
+ export declare class StringKeyColumn extends SortKeyColumn {
82
+ readonly field: string;
83
+ readonly kind: "string";
84
+ readonly cacheable = true;
85
+ private readonly _keys;
86
+ constructor(field: string, values: readonly unknown[]);
87
+ compare(i: number, j: number): number;
88
+ stringKeyAt(i: number): string | null;
89
+ }
@@ -0,0 +1,34 @@
1
+ import { IRowSource, ISortKeyColumn, ISortKeyStore, SortComparator, SortDir, SortSpec } from './ports.js';
2
+ /**
3
+ * 행 원천에서 정렬할 행의 한 컬럼 값을 한 번 읽어 키 열을 만들고, 보관할 수 있으면 들고 있다.
4
+ *
5
+ * Reads one field of the rows being sorted once, builds its key column, and keeps it when that is safe.
6
+ */
7
+ export declare class SortKeyStore implements ISortKeyStore {
8
+ private readonly _source;
9
+ private readonly _kept;
10
+ constructor(_source: IRowSource);
11
+ /** 진단: 지금 보관 중인 컬럼 수. / Diagnostic: number of columns currently kept. */
12
+ get size(): number;
13
+ /**
14
+ * @param start 이번 정렬의 출발 순서. 생략하면 원천의 지금 표시 순서 / this sort's start order; defaults to the source's display order
15
+ */
16
+ keyColumnFor(spec: SortSpec, cmp: SortComparator, start?: readonly number[]): ISortKeyColumn;
17
+ /**
18
+ * 정렬이 끝났다는 알림. key 가 이 저장소가 내준(보관 중인) 키 열이면 결과 순서만 기억해 둔다 — 등수는
19
+ * 같은 컬럼을 다시 정렬할 때 매긴다(첫 정렬에 이웃 비교 n 번을 더 치르지 않으려고).
20
+ *
21
+ * Notification that a sort finished. If key is a column this store handed out and keeps, only the order is
22
+ * remembered; ranks are taken on the next sort of the same column, so the first sort pays nothing extra.
23
+ */
24
+ noteSorted(key: ISortKeyColumn, sorted: ArrayLike<number>, dir: SortDir | undefined): void;
25
+ clear(): void;
26
+ /**
27
+ * 낡지 않은 보관분을 다시 쓴다 — 지난 정렬 결과를 알면 거기서 등수를 매겨(이웃 비교 n 번) 등수 키 열로,
28
+ * 등수가 이번에 정렬할 행을 다 덮지 못하면(필터가 풀려 행이 늘어난 경우 등) 뽑아 둔 키 열 그대로.
29
+ *
30
+ * Reuses a fresh entry: ranks are taken from the last sort result (n neighbour comparisons) and handed out as
31
+ * a ranked column; if they do not cover every row to sort now (e.g. a filter was lifted), the kept key column.
32
+ */
33
+ private _reuse;
34
+ }
@@ -0,0 +1,54 @@
1
+ import { IRowSource, ISorter, ISortKeyColumn, ISortKeyStore, ISortOrderer, ISortRunner, SortComparator, SortJob, SortSpec } from './ports.js';
2
+ /** 따로 내려받는 조각이 내놓는 것 — 머리말 기억 정렬과 그것을 고르는 비용 어림. / What the lazily loaded chunk provides. */
3
+ export interface PrefixSortChunk {
4
+ readonly LcpMergeOrderer: new () => ISortOrderer;
5
+ readonly SortCostEstimate: {
6
+ pickOrderer(orderers: readonly ISortOrderer[], keys: readonly ISortKeyColumn[], start: readonly number[]): ISortOrderer;
7
+ };
8
+ }
9
+ /** 생성 옵션. / Construction options. */
10
+ export interface SorterOptions {
11
+ /** 머리말 기억 정렬 조각을 내려받는 함수(없으면 비교 정렬만). / Loader for the prefix-sort chunk (none: comparison only). */
12
+ readonly loadPrefixSort?: () => Promise<PrefixSortChunk>;
13
+ }
14
+ /**
15
+ * 정렬 파사드. sortNow 는 늘 동기로 끝난 순서를 돌려준다(orderBy 의 공개 뜻).
16
+ *
17
+ * Sorting facade; sortNow always returns a finished order synchronously (orderBy's public meaning).
18
+ */
19
+ export declare class Sorter implements ISorter {
20
+ private readonly _source;
21
+ private readonly _store;
22
+ private readonly _sync;
23
+ /** 진단: 마지막 정렬이 쓴 순서 매기기의 이름표. / Diagnostic: id of the orderer used by the last sort. */
24
+ lastOrdererId: string;
25
+ /** 머리말 정렬 조각 받기가 끝나면(실패 포함) 풀리는 약속 — 시험·진단용. / Settles once the chunk load ends (incl. failure). */
26
+ prefixSortReady: Promise<void>;
27
+ private _orderers;
28
+ private _pick;
29
+ private _load;
30
+ /**
31
+ * @param source 행 원천(원 자료 + 지금 표시 순서) / row source (data + current display order)
32
+ * @param store 키 열을 주는 곳 / key-column store
33
+ * @param orderers 순서 매기기 후보(받아 주는 첫 전략을 씀 — 조각이 오면 비용 어림이 고름) / candidate orderers
34
+ * @param sync 한 번에 끝내는 실행기 / run-to-completion runner
35
+ * @param opts 머리말 정렬 조각 로더 / prefix-sort chunk loader
36
+ */
37
+ constructor(_source: IRowSource, _store: ISortKeyStore, orderers: readonly ISortOrderer[], _sync: ISortRunner, opts?: SorterOptions);
38
+ /**
39
+ * @param start 출발 순서. 생략하면 원천의 지금 표시 순서(원천을 쥐고 직접 부르는 쪽의 편의 — 표시 순서의 주인은 늘 넘긴다)
40
+ * / start order; defaults to the source's current display order (the display-order owner always passes it)
41
+ */
42
+ sortNow(specs: readonly SortSpec[], cmp: SortComparator, start?: readonly number[]): readonly number[];
43
+ sortInteractive(specs: readonly SortSpec[], cmp: SortComparator, start?: readonly number[]): SortJob;
44
+ private _start;
45
+ private _ordererFor;
46
+ /**
47
+ * 글자 키 하나로 큰 표를 정렬할 때 처음 한 번만 머리말 정렬 조각을 부른다. 이번 정렬은 기다리지 않는다.
48
+ * 받기에 실패하면 비교 정렬로 계속(결과는 같고 느릴 뿐).
49
+ *
50
+ * Fetches the prefix-sort chunk once, on the first large single-string-key sort; this sort does not wait.
51
+ * A failed fetch keeps the comparison sort (same result, only slower).
52
+ */
53
+ private _fetchPrefixSortIfUseful;
54
+ }
@@ -0,0 +1,9 @@
1
+ import { ISortKeyColumn, ISortOrderer, ISortRunner, SortDir, SortJob } from './ports.js';
2
+ /**
3
+ * 부른 자리에서 순서 매기기를 한 번 부르고 끝난 작업을 돌려준다. 순서는 매기지 않는다(전략에 맡김).
4
+ *
5
+ * Calls the orderer once, synchronously, and returns a finished job; ordering itself is the orderer's job.
6
+ */
7
+ export declare class SyncSortRunner implements ISortRunner {
8
+ run(start: readonly number[], keys: readonly ISortKeyColumn[], dirs: readonly SortDir[], orderer: ISortOrderer): SortJob;
9
+ }
@@ -0,0 +1,5 @@
1
+ /**
2
+ * a, b 의 공통 머리말 길이. h 글자까지는 같다고 이미 안다(그 다음부터 센다).
3
+ * Common prefix length of a and b, counting from h (the first h characters are known equal).
4
+ */
5
+ export declare function commonPrefix(a: string, b: string, h: number): number;
@@ -0,0 +1,140 @@
1
+ /** DataLayer 가 구현. 정렬 출발점 = 지금 표시 순서(삭제 행 제외) — 안정 정렬의 「직전 순서」 보존. */
2
+ export interface IRowSource<T = unknown> {
3
+ /** 원 자료(읽기 전용 뷰 — 복사 아님). */
4
+ readonly rows: readonly T[];
5
+ displayOrder(): readonly number[];
6
+ }
7
+ export type SortDir = 'asc' | 'desc';
8
+ export interface SortSpec {
9
+ readonly field: string;
10
+ readonly dir: SortDir;
11
+ }
12
+ /** 지금 applySort 의 비교자 꼴(OverrideKernel 'sortComparator' 슬롯과 같은 서명). */
13
+ /** 정렬 목록에 방향이 빠지면 dir 은 undefined 로 온다(채우지 않는다 — 옛 고리와 같음). */
14
+ export type SortComparator = (a: unknown, b: unknown, field: string, dir: SortDir | undefined) => number;
15
+ /** 시간 자르기 포트(rAF/MessageChannel 은 구현, 시험은 가짜 시계). */
16
+ export interface ITaskScheduler {
17
+ now(): number;
18
+ next(cb: () => void): number;
19
+ cancel(id: number): void;
20
+ }
21
+ /**
22
+ * ① 키 뽑기 — 한 컬럼의 값을 비교 가능한 키로 한 번 뽑아 둔다.
23
+ * 구현: NumberKeyColumn(Float64Array + null 표지) / StringKeyColumn(String() 한 번) / GeneralKeyColumn(지금 비교자 그대로).
24
+ * 불변: compare 의 부호는 DEFAULT_SORT_COMPARATOR(오름차순, null/undefined 먼저)와 같다.
25
+ * 옛 비교자가 일관되지 않는 값(NaN 이 섞인 숫자 열 등 — 비교 결과가 NaN)이 있으면 Number/String 키 열을 만들지 않고
26
+ * GeneralKeyColumn 으로 떨어지며, ComparisonOrderer 는 그 경우 **같은 출발 배열에 옛 비교자를 그대로 넘겨 Array.prototype.sort** 를 부른다
27
+ * → 같은 엔진·같은 입력·같은 비교자라 순서가 지금과 바이트까지 같다.
28
+ */
29
+ export interface ISortKeyColumn {
30
+ readonly field: string;
31
+ readonly kind: 'number' | 'string' | 'general' | 'ranked';
32
+ /** 원시값만 보관 가능(Date 등 객체 값은 false — 제자리 수정이 === 를 통과하므로). */
33
+ readonly cacheable: boolean;
34
+ /** 모델 행 번호 i, j 의 오름차순 비교. */
35
+ compare(i: number, j: number): number;
36
+ /** 문자열 키면 그 키(순서 매기기 전략이 머리말 기억·기수 정렬에 쓴다), 아니면 null. */
37
+ stringKeyAt(i: number): string | null;
38
+ }
39
+ /** 등수 보관(값 객체). 같은 값 = 같은 등수. */
40
+ export interface IRankIndex {
41
+ readonly field: string;
42
+ compare(i: number, j: number): number;
43
+ /** O(n) 낡음 검사: 같은 자리의 원시값이 보관값과 === 인가. */
44
+ isFreshFor(rows: readonly unknown[]): boolean;
45
+ }
46
+ /**
47
+ * 등수 보관의 유일한 주인. 무효화 호출을 변경 지점에 흩지 않는다(낡음은 값 검사로).
48
+ * 등수가 순서 매기기에 들어가는 길 — 저장소는 비교 함수가 아니라 **키 열**을 준다.
49
+ * 등수가 있으면 `RankedKeyColumn`(ISortKeyColumn 의 한 구현, 정수 비교·stringKeyAt=null), 없으면 새로 뽑은 Number/String/General 키 열.
50
+ * 그래서 ISortOrderer 는 등수가 있든 없든 같은 입력(ISortKeyColumn[])을 받는다. 같은 값 = 같은 등수라 순서 결과는 같다.
51
+ */
52
+ export interface ISortKeyStore {
53
+ /** 낡았으면 다시 만들고, cacheable 이 아니면 보관하지 않는다. */
54
+ /** start = 이번 정렬의 출발 순서(원 자료 색인). 이 행들의 값만 읽는다. */
55
+ keyColumnFor(spec: SortSpec, cmp: SortComparator, start: readonly number[]): ISortKeyColumn;
56
+ /**
57
+ * 정렬이 끝났다는 알림(선택). key 가 이 저장소가 내준 키 열이면 결과 순서를 기억해 두었다가, 같은 컬럼을 다시 정렬할 때
58
+ * 그 순서에서 등수를 매긴다(이웃 비교 n 번). 첫 키에 대해서만 부른다.
59
+ */
60
+ noteSorted?(key: ISortKeyColumn, sorted: ArrayLike<number>, dir: SortDir | undefined): void;
61
+ /** setData·clearData 때 메모리만 푼다. */
62
+ clear(): void;
63
+ }
64
+ /**
65
+ * ② 순서 매기기 — 출발 순서 + 비교 → 안정 정렬 결과.
66
+ * 구현: ComparisonOrderer(안정 비교 정렬) · LcpMergeOrderer(문자열 키 전용, 표본을 정렬한 뒤 이웃 공통 머리말 평균으로 고름).
67
+ * 불변: 결과 순서 = 출발 순서에서 안정 비교 정렬한 순서(어느 구현이든 같은 결과 — 대조 시험).
68
+ */
69
+ export interface ISortOrderer {
70
+ readonly id: string;
71
+ /** 이 키·행 수에 쓸 수 있나(예: 문자열 키 전용 전략은 general 키면 false). */
72
+ accepts(keys: readonly ISortKeyColumn[], rowCount: number): boolean;
73
+ order(start: readonly number[], keys: readonly ISortKeyColumn[], dirs: readonly SortDir[]): Int32Array;
74
+ }
75
+ /** 진행 중 정렬 하나. onDone 은 많아야 한 번, cancel 뒤엔 안 불림. */
76
+ export interface SortJob {
77
+ readonly done: boolean;
78
+ cancel(): void;
79
+ onDone(cb: (order: Int32Array) => void): void;
80
+ /**
81
+ * 그 자리에서 동기로 끝내고 전체 순서를 돌려준다(이미 끝났으면 그대로).
82
+ * DataLayer 는 **모든 공개 메서드의 첫 줄**에서 미확정이면 이것을 먼저 부른다(예외: 순서와 무관한 메서드).
83
+ * 미확정 중 applySort·applyFilter·setFindFilter·setData·clearData 는 settle 이 아니라 cancel 후 진행.
84
+ */
85
+ settle(): Int32Array;
86
+ /**
87
+ * 「화면 구간 먼저」 실행기만 — 최종 순서의 [start, end) 구간(확정된 값)을 돌려준다. 못 주면 null.
88
+ * 이 구간은 최종 순서와 한 칸도 다르지 않다(대조 시험).
89
+ */
90
+ peekWindow(start: number, end: number): Int32Array | null;
91
+ }
92
+ /**
93
+ * ③ 실행 방식 — 한 번에(SyncSortRunner) / 조각으로(SlicedSortRunner, 지연 청크, 조각 8ms) /
94
+ * 화면 구간 먼저(WindowFirstSortRunner — 조건이 맞을 때만: 구간 고르기(quickselect 두 번) + 구간 정렬 → 나머지는 조각으로).
95
+ * 양보 수단: scheduler.yield() 가 있으면 쓰고 없으면 MessageChannel(ITaskScheduler 구현 안).
96
+ * 구간 먼저 실행기에 넘기는 구간은 run 뒤 setWindow 로 준다.
97
+ */
98
+ export interface ISortRunnerWindowed {
99
+ setWindow(start: number, end: number): void;
100
+ }
101
+ /**
102
+ * 불변: 같은 입력이면 어느 실행기든 같은 순서. 그리드당 진행 중 작업은 많아야 하나(새 작업이 앞 작업 취소).
103
+ */
104
+ export interface ISortRunner {
105
+ run(start: readonly number[], keys: readonly ISortKeyColumn[], dirs: readonly SortDir[], orderer: ISortOrderer): SortJob;
106
+ }
107
+ /** 「얼마나 걸릴까」의 주인. 틀려도 결과는 같고 늦게 끝날 뿐이라 정교할 필요 없다. */
108
+ export interface ISortCostEstimate {
109
+ readonly expectedMs: number;
110
+ prefersSlicing(thresholdMs?: number): boolean;
111
+ }
112
+ /** 조립 파사드 — DataLayer·SortFilterManager 가 아는 것은 이것뿐. / Assembly facade for sorting. */
113
+ export interface ISorter {
114
+ /**
115
+ * orderBy()·applySort 용 — 늘 동기. 사용자 비교자면 general 키로 지금 비교 그대로.
116
+ * start = 출발 순서(표시 순서의 주인이 정렬을 시작할 때 한 번 뽑아 넘김 — 같은 값끼리는 이 순서를 지킨다).
117
+ */
118
+ sortNow(specs: readonly SortSpec[], cmp: SortComparator, start: readonly number[]): readonly number[];
119
+ /** 머리글 누름 — 추정이 문턱(100ms)을 넘으면 나눠서. */
120
+ sortInteractive(specs: readonly SortSpec[], cmp: SortComparator, start: readonly number[]): SortJob;
121
+ }
122
+ /**
123
+ * 그리기 전용 접근자(DataLayer 가 구현, 내부 — 공개 API 아님). 첫 화면을 settle 없이 그릴 수 있는 유일한 길.
124
+ * 미확정이면 peekWindow 로 받은 [s, e) 안은 확정 구간에서, 밖은 settle 후. 쓰는 곳: 본문 그리개 · FlatRowModel.resolveForPaint 만.
125
+ */
126
+ export interface IPaintRowSource<T = unknown> {
127
+ paintRowAt(viewIndex: number): T | undefined;
128
+ paintRowStateAt(viewIndex: number): string;
129
+ /** 진단: 지금까지 settle 이 실제로 일어난 횟수(시험 「첫 프레임 settle 0」). */
130
+ readonly settleCount: number;
131
+ /** 진단: 지금 미확정 정렬이 있나. */
132
+ readonly pending: boolean;
133
+ }
134
+ /**
135
+ * 시험 이음새(내부) — Sorter 생성자 옵션. 실행기 고르기를 작은 자료에서도 강제한다. 기본 undefined(비용 추정으로 고름).
136
+ * 'windowFirst' = WindowFirstSortRunner. 헤드리스 파일이라 DOM 전역 이름과 같은 낱말('window')을 값으로 쓰지 않는다.
137
+ */
138
+ export interface SorterTestOptions {
139
+ readonly forceRunner?: 'sync' | 'sliced' | 'windowFirst';
140
+ }
@@ -0,0 +1,28 @@
1
+ type Translate = (key: string, params?: Record<string, string | number>) => string;
2
+ /** 진척바 생성 옵션. / Options for the progress view. */
3
+ export interface ExportProgressViewOptions {
4
+ /** i18n 해석기(미주입 시 영문 기본 문구). / i18n resolver (English fallback when absent). */
5
+ t?: Translate | undefined;
6
+ /** 취소 단추 콜백. / Cancel button callback. */
7
+ onCancel?: () => void;
8
+ }
9
+ export declare class ExportProgressView {
10
+ private readonly opts;
11
+ private _root;
12
+ private _bar;
13
+ private _text;
14
+ private _btn;
15
+ private _closed;
16
+ private _failed;
17
+ private _prevFocus;
18
+ constructor(opts?: ExportProgressViewOptions);
19
+ private _t;
20
+ /** 진행 갱신. / Update progress. */
21
+ update(done: number, total: number): void;
22
+ /** 오류 표시(취소 단추는 닫기 역할로 바뀐다). / Show an error; the button becomes a close button. */
23
+ fail(message?: string): void;
24
+ /** 닫기. 여러 번 불러도 안전. / Close; idempotent. */
25
+ close(): void;
26
+ get isOpen(): boolean;
27
+ }
28
+ export {};
@@ -35,10 +35,33 @@ export interface IWorkbookWriter {
35
35
  /** SheetModel → 바이트(sink 로 기록). / SheetModel → bytes (written to sink). */
36
36
  write(model: SheetModel, sink: IByteSink): Promise<number>;
37
37
  }
38
+ /** 스트리밍 시트 개시 정보. / Streaming sheet init info. */
39
+ export interface XlsxStreamInit {
40
+ readonly sheetName: string;
41
+ readonly header: ReadonlyArray<string>;
42
+ readonly colWidthsPx: ReadonlyArray<number>;
43
+ /** false 면 머리글 행을 쓰지 않는다(기본 true). / false omits the header row (default true). */
44
+ readonly includeHeader?: boolean;
45
+ }
46
+ /** 스트리밍 쓰기 세션(행 청크 단위). / Streaming write session (row-chunk granularity). */
47
+ export interface IXlsxStreamSession {
48
+ /** 행 청크 추가(sink 쓰기를 await = 백프레셔). / Append a row chunk (awaits sink writes). */
49
+ appendRows(rows: ReadonlyArray<ReadonlyArray<SheetCell>>, merges?: ReadonlyArray<MergeRegion>): Promise<void>;
50
+ /** 마무리(총 바이트 반환). sink.close 는 호출자 몫. / Finish; returns total bytes (caller closes sink). */
51
+ finish(): Promise<number>;
52
+ /** 중단(이후 쓰기 없음). / Abort. */
53
+ abort(): void;
54
+ }
55
+ /** 스트리밍 가능한 쓰기기 SPI. / Streaming-capable writer SPI. */
56
+ export interface IStreamingWorkbookWriter extends IWorkbookWriter {
57
+ openStream(init: XlsxStreamInit, sink: IByteSink): Promise<IXlsxStreamSession>;
58
+ }
38
59
  /** xlsx 채널 옵션. / xlsx channel options. */
39
60
  export interface XlsxChannelOptions {
40
61
  readonly sheetName?: string;
41
62
  readonly includeProvenance?: boolean;
63
+ /** 스트리밍: false 면 머리글 행 제외(기본 true). / Streaming: false omits the header row (default true). */
64
+ readonly includeHeader?: boolean;
42
65
  }
43
66
  /** xlsx 직렬화 전략(순수 접기 + 주입 인코더). / xlsx serialization strategy (pure fold + injected writer). */
44
67
  export declare class XlsxChannel {
@@ -50,4 +73,10 @@ export declare class XlsxChannel {
50
73
  /** 순수: 소스 → SheetModel(파리티 골든 대상). / Pure: source → SheetModel (parity golden target). */
51
74
  buildModel(source: IArtifactSource, ctx?: ExportRunCtx): Promise<SheetModel>;
52
75
  write(source: IArtifactSource, sink: IByteSink, ctx?: ExportRunCtx): Promise<ExportResult>;
76
+ /**
77
+ * 스트리밍 쓰기: 전 행을 적재하지 않고 청크 단위로 writer 에 흘린다(머리글 먼저).
78
+ * 취소(ctx.signal)·진척(ctx.onProgress)·백프레셔(sink.write await) 지원. 기존 write 는 불변.
79
+ * / Streaming write: flows row chunks to the writer without materializing all rows.
80
+ */
81
+ writeStreaming(source: IArtifactSource, sink: IByteSink, ctx?: ExportRunCtx): Promise<ExportResult>;
53
82
  }