comins-table 0.2.2 → 0.2.3

package/dist/react/core-compat.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"core-compat.d.ts","sourceRoot":"","sources":["../../src/react/core-compat.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"core-compat.d.ts","sourceRoot":"","sources":["../../src/react/core-compat.ts"],"names":[],"mappings":"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"}

package/dist/react/state.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../src/react/state.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAC3G,OAAO,KAAK,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAC;AAE9E,OAAO,EAAsB,KAAK,yBAAyB,EAAE,MAAM,yBAAyB,CAAC;AAK7F,KAAK,0BAA0B,CAAC,KAAK,IAAI,IAAI,CAAC,yBAAyB,CAAC,KAAK,CAAC,EAAE,SAAS,GAAG,WAAW,CAAC,GAAG;IACzG,OAAO,EAAE,gBAAgB,CAAC,KAAK,CAAC,CAAC;IACjC,SAAS,EAAE,IAAI,CAAC,qBAAqB,CAAC,KAAK,CAAC,EAAE,cAAc,GAAG,SAAS,GAAG,MAAM,GAAG,UAAU,GAAG,YAAY,GAAG,YAAY,CAAC,CAAC;CAC/H,CAAC;AAEF,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,EAAE,0BAA0B,CAAC,KAAK,CAAC;;;;;;;;;;;;;;;;;;;;;EAUpF;AAED,KAAK,eAAe,CAAC,KAAK,IAAI;IAC5B,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,KAAK,EAAE,KAAK,IAAI,CAAC;IACvC,iBAAiB,CAAC,EAAE,CAAC,SAAS,EAAE,oBAAoB,KAAK,IAAI,CAAC;IAC9D,oBAAoB,CAAC,EAAE,CAAC,MAAM,EAAE,kBAAkB,KAAK,IAAI,CAAC;IAC5D,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,eAAe,GAAG,IAAI,KAAK,IAAI,CAAC;IACtD,iBAAiB,CAAC,EAAE,CAAC,SAAS,EAAE,eAAe,KAAK,IAAI,CAAC;CAC1D,CAAC;AAEF,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,OAAO,EAAE,gBAAgB,CAAC,KAAK,CAAC,EAAE,IAAI,EAAE,gBAAgB,CAAC,KAAK,CAAC,EAAE,SAAS,EAAE,eAAe,CAAC,KAAK,CAAC,EAAE,OAAO,GAAE;IAAE,mBAAmB,CAAC,EAAE,OAAO,CAAA;CAAO,QAOjM;AAED,+EAA+E;AAC/E,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,OAAO,EAAE,gBAAgB,CAAC,KAAK,CAAC,EAAE,IAAI,EAAE,gBAAgB,CAAC,KAAK,CAAC,EAAE,SAAS,EAAE,eAAe,CAAC,KAAK,CAAC,QAKhJ"}
+{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../src/react/state.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAC3G,OAAO,KAAK,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAC;AAE9E,OAAO,EAAsB,KAAK,yBAAyB,EAAE,MAAM,yBAAyB,CAAC;AAK7F,KAAK,0BAA0B,CAAC,KAAK,IAAI,IAAI,CAAC,yBAAyB,CAAC,KAAK,CAAC,EAAE,SAAS,GAAG,WAAW,CAAC,GAAG;IACzG,OAAO,EAAE,gBAAgB,CAAC,KAAK,CAAC,CAAC;IACjC,SAAS,EAAE,IAAI,CAAC,qBAAqB,CAAC,KAAK,CAAC,EAAE,cAAc,GAAG,SAAS,GAAG,MAAM,GAAG,UAAU,GAAG,YAAY,GAAG,YAAY,CAAC,CAAC;CAC/H,CAAC;AAEF,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,EAAE,0BAA0B,CAAC,KAAK,CAAC;;;;;;;;;;;;;;;;;;;;;EAUpF;AAED,KAAK,eAAe,CAAC,KAAK,IAAI;IAC5B,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,KAAK,EAAE,KAAK,IAAI,CAAC;IACvC,iBAAiB,CAAC,EAAE,CAAC,SAAS,EAAE,oBAAoB,KAAK,IAAI,CAAC;IAC9D,oBAAoB,CAAC,EAAE,CAAC,MAAM,EAAE,kBAAkB,KAAK,IAAI,CAAC;IAC5D,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,eAAe,GAAG,IAAI,KAAK,IAAI,CAAC;IACtD,iBAAiB,CAAC,EAAE,CAAC,SAAS,EAAE,eAAe,KAAK,IAAI,CAAC;CAC1D,CAAC;AAEF,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,OAAO,EAAE,gBAAgB,CAAC,KAAK,CAAC,EAAE,IAAI,EAAE,gBAAgB,CAAC,KAAK,CAAC,EAAE,SAAS,EAAE,eAAe,CAAC,KAAK,CAAC,EAAE,OAAO,GAAE;IAAE,mBAAmB,CAAC,EAAE,OAAO,CAAA;CAAO,QAOjM;AAED,+EAA+E;AAC/E,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,OAAO,EAAE,gBAAgB,CAAC,KAAK,CAAC,EAAE,IAAI,EAAE,gBAAgB,CAAC,KAAK,CAAC,EAAE,SAAS,EAAE,eAAe,CAAC,KAAK,CAAC,QAOhJ"}

package/dist/react/value-filter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"value-filter.d.ts","sourceRoot":"","sources":["../../src/react/value-filter.tsx"],"names":[],"mappings":"AACA,OAAO,EAA6D,KAAK,8BAA8B,EAAE,KAAK,sBAAsB,EAAiC,MAAM,cAAc,CAAC;AAE1L,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,gBAAgB,CAAC;AAC/D,OAAO,KAAK,EAAE,wBAAwB,EAAoF,kCAAkC,EAAyB,oCAAoC,EAAE,MAAM,sBAAsB,CAAC;AAqBxP,wBAAgB,wBAAwB,CAAC,KAAK,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,MAAM,IAAI,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,KAAK,CAAC,aAAa,CAAC;IAAC,IAAI,CAAC,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,WAAW,GAAG,IAAI,KAAK,IAAI,CAAA;CAAE,GAAG,wBAAwB,CAoBnQ;AAsBD,wBAAgB,cAAc,CAAC,KAAK,EAAE,KAAK,EAAE;IAC3C,MAAM,EAAE,wBAAwB,CAAC,KAAK,CAAC,CAAC;IAAC,MAAM,EAAE,8BAA8B,CAAC,KAAK,CAAC,CAAC;IAAC,OAAO,EAAE,OAAO,CAAC;IACzG,IAAI,EAAE,OAAO,CAAC;IAAC,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,sBAAsB,EAAE,KAAK,IAAI,CAAC;IAAC,KAAK,EAAE,MAAM,IAAI,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;CACzG;;;;;;EAmCA;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,EAAE,MAAM,EAAE,EAAE;IAAE,MAAM,EAAE,kCAAkC,CAAC,KAAK,CAAC,CAAA;CAAE,+BAaxG;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,EAAE,oCAAoC,CAAC,KAAK,CAAC,EAAE,QAAQ,EAAE,KAAK,CAAC,SAAS,6BAGxH;AACD,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,MAAM,EAAE,oCAAoC,CAAC,KAAK,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEhG"}
+{"version":3,"file":"value-filter.d.ts","sourceRoot":"","sources":["../../src/react/value-filter.tsx"],"names":[],"mappings":"AACA,OAAO,EAA6D,KAAK,8BAA8B,EAAE,KAAK,sBAAsB,EAAiC,MAAM,cAAc,CAAC;AAE1L,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,gBAAgB,CAAC;AAC/D,OAAO,KAAK,EAAE,wBAAwB,EAAoF,kCAAkC,EAAyB,oCAAoC,EAAE,MAAM,sBAAsB,CAAC;AA6BxP,wBAAgB,wBAAwB,CAAC,KAAK,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,MAAM,IAAI,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,KAAK,CAAC,aAAa,CAAC;IAAC,IAAI,CAAC,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,WAAW,GAAG,IAAI,KAAK,IAAI,CAAA;CAAE,GAAG,wBAAwB,CAoBnQ;AAsBD,wBAAgB,cAAc,CAAC,KAAK,EAAE,KAAK,EAAE;IAC3C,MAAM,EAAE,wBAAwB,CAAC,KAAK,CAAC,CAAC;IAAC,MAAM,EAAE,8BAA8B,CAAC,KAAK,CAAC,CAAC;IAAC,OAAO,EAAE,OAAO,CAAC;IACzG,IAAI,EAAE,OAAO,CAAC;IAAC,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,sBAAsB,EAAE,KAAK,IAAI,CAAC;IAAC,KAAK,EAAE,MAAM,IAAI,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;CACzG;;;;;;EAmCA;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,EAAE,MAAM,EAAE,EAAE;IAAE,MAAM,EAAE,kCAAkC,CAAC,KAAK,CAAC,CAAA;CAAE,+BAaxG;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,EAAE,oCAAoC,CAAC,KAAK,CAAC,EAAE,QAAQ,EAAE,KAAK,CAAC,SAAS,6BAGxH;AACD,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,MAAM,EAAE,oCAAoC,CAAC,KAAK,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEhG"}

package/dist/selection.js

@@ -1,2 +1,2 @@
-import { C as e, I as t, L as n, R as r, T as i, i as a, r as o, v as s, w as c } from "./core-compat-BO-JJudO.js";
+import { C as e, I as t, L as n, R as r, T as i, i as a, r as o, v as s, w as c } from "./core-compat-CQ_YgTHr.js";
 export { o as clearCominsCellRange, a as clearCominsSelection, s as getCominsSelectedCellRange, e as isCominsCellInSelectedRange, c as isCominsCellSelected, i as isCominsRowSelected, t as selectCell, n as selectCellRange, r as selectRow };

package/dist/tree-drag.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tree-drag.d.ts","sourceRoot":"","sources":["../src/tree-drag.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAC;AAC1C,OAAO,KAAK,EAAE,cAAc,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAGlI,OAAO,EAAsB,KAAK,qBAAqB,EAA+B,KAAK,cAAc,EAAE,KAAK,uBAAuB,EAAE,KAAK,oBAAoB,EAAE,MAAM,QAAQ,CAAC;AAEnL,MAAM,MAAM,8BAA8B,CAAC,CAAC,IAAI;IAC9C,KAAK,EAAE,KAAK,CAAC,YAAY,CAAC,WAAW,CAAC,GAAG,KAAK,CAAC,aAAa,CAAC,WAAW,CAAC,CAAC;IAC1E,GAAG,EAAE,cAAc,CAAC,CAAC,CAAC,CAAC;CACxB,CAAC;AACF,MAAM,MAAM,wBAAwB,CAAC,CAAC,IAAI;IACxC,KAAK,EAAE,YAAY,GAAG,aAAa,CAAC;IACpC,GAAG,EAAE,cAAc,CAAC,CAAC,CAAC,CAAC;IACvB,MAAM,EAAE,mBAAmB,CAAC;CAC7B,CAAC;AACF,MAAM,MAAM,6BAA6B,CAAC,CAAC,IAAI;IAC7C,KAAK,EAAE,YAAY,GAAG,aAAa,GAAG,IAAI,CAAC;IAC3C,GAAG,EAAE,cAAc,CAAC,CAAC,CAAC,CAAC;IACvB,MAAM,CAAC,EAAE,mBAAmB,CAAC;IAC7B,MAAM,EAAE,mBAAmB,CAAC;IAC5B,MAAM,EAAE,mBAAmB,CAAC;CAC7B,CAAC;AAEF,KAAK,OAAO,CAAC,CAAC,IAAI;IAChB,IAAI,EAAE,SAAS,cAAc,CAAC,CAAC,CAAC,EAAE,CAAC;IACnC,OAAO,EAAE,SAAS,oBAAoB,CAAC,CAAC,CAAC,EAAE,CAAC;IAC5C,QAAQ,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,WAAW,CAAC;IACjD,MAAM,CAAC,EAAE,uBAAuB,CAAC,CAAC,CAAC,CAAC;IACpC,MAAM,EAAE,OAAO,CAAC;IAChB,QAAQ,CAAC,EAAE,mBAAmB,CAAC,CAAC,CAAC,CAAC;IAClC,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,cAAc,CAAC,CAAC,CAAC,EAAE,KAAK,IAAI,CAAC;IACnD,eAAe,CAAC,EAAE,CAAC,OAAO,EAAE,8BAA8B,CAAC,CAAC,CAAC,KAAK,OAAO,GAAG,IAAI,CAAC;IACjF,SAAS,CAAC,EAAE,CAAC,OAAO,EAAE,wBAAwB,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC;IAC3D,cAAc,CAAC,EAAE,CAAC,OAAO,EAAE,6BAA6B,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC;CACtE,CAAC;AACF,KAAK,OAAO,CAAC,CAAC,IAAI;IAAE,OAAO,EAAE,qBAAqB,CAAC,CAAC,CAAC,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,CAAC;AAUxE,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;uCAGrB,WAAW,KAAK,IAAI;;;2BAqFvB,KAAK,CAAC,YAAY,CAAC,WAAW,CAAC,OAAO,cAAc,CAAC,CAAC,CAAC;uBA+D3D,KAAK,CAAC,aAAa,CAAC,WAAW,CAAC,OAAO,cAAc,CAAC,CAAC,CAAC;;EAcnF"}
+{"version":3,"file":"tree-drag.d.ts","sourceRoot":"","sources":["../src/tree-drag.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAC;AAC1C,OAAO,KAAK,EAAE,cAAc,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAGlI,OAAO,EAAsB,KAAK,qBAAqB,EAA+B,KAAK,cAAc,EAAE,KAAK,uBAAuB,EAAE,KAAK,oBAAoB,EAAE,MAAM,QAAQ,CAAC;AAEnL,MAAM,MAAM,8BAA8B,CAAC,CAAC,IAAI;IAC9C,KAAK,EAAE,KAAK,CAAC,YAAY,CAAC,WAAW,CAAC,GAAG,KAAK,CAAC,aAAa,CAAC,WAAW,CAAC,CAAC;IAC1E,GAAG,EAAE,cAAc,CAAC,CAAC,CAAC,CAAC;CACxB,CAAC;AACF,MAAM,MAAM,wBAAwB,CAAC,CAAC,IAAI;IACxC,KAAK,EAAE,YAAY,GAAG,aAAa,CAAC;IACpC,GAAG,EAAE,cAAc,CAAC,CAAC,CAAC,CAAC;IACvB,MAAM,EAAE,mBAAmB,CAAC;CAC7B,CAAC;AACF,MAAM,MAAM,6BAA6B,CAAC,CAAC,IAAI;IAC7C,KAAK,EAAE,YAAY,GAAG,aAAa,GAAG,IAAI,CAAC;IAC3C,GAAG,EAAE,cAAc,CAAC,CAAC,CAAC,CAAC;IACvB,MAAM,CAAC,EAAE,mBAAmB,CAAC;IAC7B,MAAM,EAAE,mBAAmB,CAAC;IAC5B,MAAM,EAAE,mBAAmB,CAAC;CAC7B,CAAC;AAEF,KAAK,OAAO,CAAC,CAAC,IAAI;IAChB,IAAI,EAAE,SAAS,cAAc,CAAC,CAAC,CAAC,EAAE,CAAC;IACnC,OAAO,EAAE,SAAS,oBAAoB,CAAC,CAAC,CAAC,EAAE,CAAC;IAC5C,QAAQ,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,WAAW,CAAC;IACjD,MAAM,CAAC,EAAE,uBAAuB,CAAC,CAAC,CAAC,CAAC;IACpC,MAAM,EAAE,OAAO,CAAC;IAChB,QAAQ,CAAC,EAAE,mBAAmB,CAAC,CAAC,CAAC,CAAC;IAClC,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,cAAc,CAAC,CAAC,CAAC,EAAE,KAAK,IAAI,CAAC;IACnD,eAAe,CAAC,EAAE,CAAC,OAAO,EAAE,8BAA8B,CAAC,CAAC,CAAC,KAAK,OAAO,GAAG,IAAI,CAAC;IACjF,SAAS,CAAC,EAAE,CAAC,OAAO,EAAE,wBAAwB,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC;IAC3D,cAAc,CAAC,EAAE,CAAC,OAAO,EAAE,6BAA6B,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC;CACtE,CAAC;AACF,KAAK,OAAO,CAAC,CAAC,IAAI;IAAE,OAAO,EAAE,qBAAqB,CAAC,CAAC,CAAC,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,CAAC;AAUxE,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;uCAGrB,WAAW,KAAK,IAAI;;;2BA2FvB,KAAK,CAAC,YAAY,CAAC,WAAW,CAAC,OAAO,cAAc,CAAC,CAAC,CAAC;uBA+D3D,KAAK,CAAC,aAAa,CAAC,WAAW,CAAC,OAAO,cAAc,CAAC,CAAC,CAAC;;EAcnF"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "comins-table",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "keywords": [
     "react",
     "typescript",
@@ -39,7 +39,7 @@
     "test:core-boundary-checker": "node --test test/core-boundary-checker.node.mjs test/core-package-gate.node.mjs",
     "test:core-consumer": "node scripts/check-core-boundary.mjs",
     "test:e2e": "env -u NO_COLOR playwright test --config=playwright.config.ts --grep-invert @perf",
-    "test:perf": "env -u NO_COLOR playwright test --config=playwright.config.ts --grep @perf",
+    "test:perf": "env -u NO_COLOR playwright test --config=playwright.config.ts --grep @perf --trace=off",
     "test:run": "vitest run",
     "test:licenses": "node --test test/license-gates.node.mjs",
     "test:security": "node --test test/sensitive-data-gates.node.mjs test/package-artifact-gate.node.mjs test/npm-maintainer-gate.node.mjs",
@@ -97,6 +97,8 @@
     "@vitejs/plugin-react": "^6.1.2",
     "jsdom": "^30.1.1",
     "prism-react-renderer": "^2.4.1",
+    "react": "19.3.0",
+    "react-dom": "19.3.0",
     "react-router": "^8.4.0",
     "typescript": "^7.0.2",
     "vite": "^8.3.4",

package/styles.css

@@ -708,6 +708,7 @@
 
 .comins-table__th,
 .comins-table__td {
+  box-sizing: border-box;
   border: 0;
   height: var(--comins-table-cell-height);
   min-width: 0;
@@ -1389,9 +1390,11 @@
 }
 
 .comins-table-empty-filler td {
+  box-sizing: border-box;
   border-bottom: 0;
   border-right: 0;
   min-height: 1px;
+  padding: 0;
 }
 
 .comins-table__tr--viewport-end > .comins-table__td {
@@ -1881,3 +1884,13 @@
 .comins-column-filter__count { color: var(--comins-table-component-muted); margin-left: auto; }
 .comins-column-filter__select-all, .comins-column-filter__actions { display: flex; align-items: center; gap: 6px; }
 .comins-column-filter__no-results { color: var(--comins-table-component-muted); padding: 8px; }
+
+/* Avoid per-element paged-media UA queries on scrolling screens; retain print rules. */
+@media screen and (overflow-block: scroll) {
+  :where(
+    .comins-table__header-table > .comins-table__thead,
+    .comins-table__summary-table > tfoot
+  ) {
+    break-inside: auto;
+  }
+}

package/dist/clipboard-B_gA5e12.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"clipboard-B_gA5e12.js","names":["COMINS_MIN_COLUMN_WIDTH","parseCominsClipboardText","text","rows","row","value","quoted","closed","count","cell","index","char","findRowIndex","state","id","rowId","findColumn","column","columnId","getNestedFieldValue","field","key","setColumnWidth","getEffectiveColumnMinWidth","getEffectiveColumnMaxWidth","getRuntimeColumnWidth","clampColumnWidth","maxWidth","minWidth","width","distributeRuntimeColumnWidths","widths","columns","active","minWidths","maxWidths","boundedTargetWidth","targetWidth","sum","delta","activeIndexes","activeWeight","clamped","nextWidth","clampedWidth","setColumnWidthInsideParentGroup","group","candidate","childColumns","childId","targetColumn","siblingColumns","currentGroupWidth","siblingMinWidth","siblingMaxWidth","nextTargetWidth","nextSiblingWidths","next","normalizeCominsColumnPinned","resolveCominsColumnPinning","left","blocks","block","center","right","demotedLeft","demotedRight","effectiveLeft","effectiveRight","safeContainerWidth","containerWidth","pinnedBudget","totalWidth","current","blockSum","effectiveBlocks","leftOffset","lastLeftColumnId","rightOffset","blockIndex","columnIndex","firstRightColumnId","getCominsPinnedBlockResizeMaxWidth","target","blockId","resolved","otherPinnedWidth","total","blockTotal","minimumCenterWidth","getCominsColumnPinningSpanFragments","endIndex","startIndex","colSpan","fragments","pin","previous","normalizeColumns","normalizeColumnGroups","knownColumnIds","usedColumnIds","usedGroupIds","groups","columnGroups","children","normalizeColumnState","layout","normalizeColumnGroupState","getColumnGroupIdMap","map","findColumnGroupById","groupId","normalizeColumnOrder","knownIds","ordered","missing","flatOrder","columnById","groupIdByColumnId","groupById","isColumnPinned","isGroupPinned","createEntities","emittedGroups","entities","order","groupChildrenInOrder","currentId","declaredEntities","proposedEntities","declaredEntityByKey","entity","declaredSegmentByKey","segmentCount","movableEntitiesBySegment","proposedEntityByKey","declaredEntity","normalizedEntities","currentSegment","lockedChildIds","declaredChildSegmentById","childSegmentCount","movableChildrenBySegment","normalizedChildren","currentChildSegment","setCominsColumnWidth","setCominsColumnHidden","setCominsColumnGroupHidden","getColumnWidth","getColumnMinWidth","getColumnMaxWidth","clampWidth","distributeColumnGroupWidths","setCominsColumnGroupWidth","columnState","doesColumnMoveChangeLockedPositions","currentIndexByColumnId","nextIndexByColumnId","nextOrder","currentPositions","nextPositions","position","moveCominsColumn","sourceColumn","sourceGroupId","nextIndex","targetIndex","sourceGroup","groupChildrenInCurrent","groupStart","groupEnd","moveCominsColumnGroup","groupChildren","serializeCominsColumnLayout","applyCominsColumnLayout","getCominsVisibleColumns","pinned","getCominsHeaderRows","visibleColumns","parentRow","childRow","visibleGroupColumns","currentColumn","createEmptySelection","getCellRangeBounds","anchorRowIndex","rowIds","range","focusRowIndex","anchorColumnIndex","focusColumnIndex","selectRow","selected","options","selectRows","areCellAddressesEqual","selectCell","cells","activeCell","selectCellRange","clearCominsCellRange","clearCominsSelection","isCominsRowSelected","isCominsCellSelected","selectedCells","getCominsSelectedCellRange","bounds","rowIndex","isCominsCellInSelectedRange","defaultGetRowId","useRowsReference","areRowIdsEqual","withRows","shouldResetSelection","areSortModelsEqual","rule","normalizeSortModel","sortableColumnIds","normalized","sortModel","defaultCompare","createCominsTableState","nextRows","nextColumns","nextColumnGroups","nextSortModel","sort","columnLayout","pagination","getRowId","queryCominsRows","predicate","replaceCominsRows","addCominsRows","updateCominsRows","updateMap","updates","update","patch","deleteCominsRows","deleteIds","setCominsHeaderVisible","setCominsPagination","setCominsSortState","setCominsSortModel","nextSort","clearCominsSortState","getCominsSortedRowIndexes","indexes","sourceIndexes","leftRow","leftIndex","rightRow","rightIndex","leftValue","getCominsCellValue","rightValue","result","sortCominsRows","sortedState","getCominsPageRows","pageIndex","pageSize","start","getCominsVirtualRows","safeRowHeight","rowHeight","rowIndexes","totalRows","totalHeight","scrollTop","overscan","viewportHeight","topSpacerHeight","moveCominsRow","currentIndex","moveCominsRowToGroup","sourceIndex","targetRowIndex","sourceRow","fromGroupId","membershipChanged","targetRow","movedRow","lastTargetIndex","setNestedFieldValue","keys","firstKey","root","nextKey","existing","createCellComponentParams","resolveGuard","guard","params","canUseCellClipboard","props","kind","isCominsCellDisabled","disabled","copyCominsCell","pasteCominsCell","copied","currentRow","assignGeneratedRowId","createCopiedRowId","nextId","sourceRowId","ids","existingIds","copyCominsRow","pasteCominsRow","copyCominsCellRange","copiedRows","dataIndex","copiedCells","pasteCominsCellRange","targetColumnIndex","changed","rowOffset","copiedRow","columnOffset","copiedCell","pasteCominsText","matrix","firstRow","firstColumn","applyClipboardMatrix","max","height","y","rowStart","x","columnStart","read","fillCominsCellRange","from","source","to","pattern","mod","size"],"sources":["../src/clipboard-text.ts","../src/core/state/access.ts","../src/column-layout.ts","../src/column-pinning.ts","../src/core/layout/columns.ts","../src/core/selection/state.ts","../src/core/state/table.ts","../src/core/editing/cells.ts","../src/core/editing/clipboard.ts"],"sourcesContent":["// Limits apply before allocating a matrix or invoking application parsers.\nexport const MAX_CLIPBOARD_CHARACTERS = 1_000_000;\nexport const MAX_CLIPBOARD_CELLS = 100_000;\n\n/** Parse plain-text TSV, including spreadsheet quoted tabs, newlines and quotes. */\nexport function parseCominsClipboardText(text: string): string[][] {\n  if (text.length > MAX_CLIPBOARD_CHARACTERS) throw new Error(\"Clipboard text exceeds 1000000 characters.\");\n  const rows: string[][] = [];\n  let row: string[] = [], value = \"\", quoted = false, closed = false, count = 0;\n  const cell = () => {\n    if (++count > MAX_CLIPBOARD_CELLS) throw new Error(\"Clipboard exceeds 100000 cells.\");\n    row.push(value); value = \"\"; closed = false;\n  };\n  for (let index = 0; index < text.length; index++) {\n    const char = text[index]!;\n    if (quoted) {\n      if (char === '\"') {\n        if (text[index + 1] === '\"') { value += '\"'; index++; }\n        else { quoted = false; closed = true; }\n      } else value += char;\n    } else if (char === \"\\t\" || char === \"\\r\" || char === \"\\n\") {\n      cell();\n      if (char !== \"\\t\") {\n        rows.push(row); row = [];\n        if (char === \"\\r\" && text[index + 1] === \"\\n\") index++;\n        // A terminal spreadsheet record separator is not an extra empty Row.\n        if (index === text.length - 1) return rows;\n      }\n    } else if (closed) {\n      throw new Error(\"Unexpected text after a quoted clipboard cell.\");\n    } else if (char === '\"' && value === \"\") quoted = true;\n    else value += char;\n  }\n  if (quoted) throw new Error(\"Unclosed quoted clipboard cell.\");\n  cell(); rows.push(row);\n  return rows;\n}\n","import type { CominsRowId } from \"../model\";\n\nexport function findRowIndex(state: { rowIds: readonly CominsRowId[] }, rowId: CominsRowId) {\n  return state.rowIds.findIndex((id) => id === rowId);\n}\n\nexport function findColumn<TColumn extends { id: string }>(state: { columns: readonly TColumn[] }, columnId: string) {\n  return state.columns.find((column) => column.id === columnId);\n}\n\nexport function getNestedFieldValue(row: unknown, field: string): unknown {\n  return field.split(\".\").reduce<unknown>((value, key) => {\n    if (value == null || typeof value !== \"object\") {\n      return undefined;\n    }\n\n    return (value as Record<string, unknown>)[key];\n  }, row);\n}\n","import type { CominsColumnRuntimeState, CominsColumnGroupRuntimeState } from \"./model\";\n\n// Minimal inputs keep layout calculations independent of renderers and table state.\nexport type CominsWidthColumn = {\n  id: string;\n  width?: number;\n  minWidth?: number;\n  maxWidth?: number;\n};\nexport type CominsColumnWidthState = {\n  columns: CominsWidthColumn[];\n  columnGroups: Array<{ id: string; children: string[] }>;\n  columnState: Record<string, CominsColumnRuntimeState>;\n  columnGroupState: Record<string, CominsColumnGroupRuntimeState>;\n};\nconst COMINS_MIN_COLUMN_WIDTH = 88;\n\nexport function setColumnWidth<TState extends Pick<CominsColumnWidthState, \"columnState\">>(\n  state: TState,\n  columnId: string,\n  width: number,\n): TState {\n  return {\n    ...state,\n    columnState: {\n      ...state.columnState,\n      [columnId]: { ...state.columnState[columnId], width },\n    },\n  };\n}\n\nexport function getEffectiveColumnMinWidth(column: CominsWidthColumn) {\n  return Math.max(COMINS_MIN_COLUMN_WIDTH, column.minWidth ?? COMINS_MIN_COLUMN_WIDTH);\n}\n\nexport function getEffectiveColumnMaxWidth(column: CominsWidthColumn) {\n  return column.maxWidth ?? Number.POSITIVE_INFINITY;\n}\n\nexport function getRuntimeColumnWidth(\n  state: CominsColumnWidthState,\n  column: CominsWidthColumn,\n) {\n  return state.columnState[column.id]?.width ?? column.width ?? 100;\n}\n\nexport function clampColumnWidth(width: number, minWidth: number, maxWidth: number) {\n  return Math.min(maxWidth, Math.max(minWidth, width));\n}\n\nexport function distributeRuntimeColumnWidths(\n  state: CominsColumnWidthState,\n  columns: Array<CominsWidthColumn>,\n  targetWidth: number,\n) {\n  const widths = columns.map((column) =>\n    clampColumnWidth(getRuntimeColumnWidth(state, column), getEffectiveColumnMinWidth(column), getEffectiveColumnMaxWidth(column)),\n  );\n  const active = new Set(columns.map((_column, index) => index));\n  const minWidths = columns.map(getEffectiveColumnMinWidth);\n  const maxWidths = columns.map(getEffectiveColumnMaxWidth);\n  const boundedTargetWidth = clampColumnWidth(\n    targetWidth,\n    minWidths.reduce((sum, width) => sum + width, 0),\n    maxWidths.reduce((sum, width) => sum + width, 0),\n  );\n\n  while (active.size > 0) {\n    const currentTotal = widths.reduce((sum, width) => sum + width, 0);\n    const delta = boundedTargetWidth - currentTotal;\n\n    if (Math.abs(delta) < 0.001) {\n      break;\n    }\n\n    const activeIndexes = [...active];\n    const activeWeight = activeIndexes.reduce((sum, index) => sum + Math.max(widths[index] ?? 0, 0), 0);\n    let clamped = false;\n\n    for (const index of activeIndexes) {\n      const width = widths[index] ?? 0;\n      const weight = activeWeight > 0 ? width / activeWeight : 1 / activeIndexes.length;\n      const nextWidth = width + delta * weight;\n      const clampedWidth = clampColumnWidth(nextWidth, minWidths[index] ?? 0, maxWidths[index] ?? Number.POSITIVE_INFINITY);\n\n      widths[index] = clampedWidth;\n\n      if (Math.abs(clampedWidth - nextWidth) > 0.001) {\n        active.delete(index);\n        clamped = true;\n      }\n    }\n\n    if (!clamped) {\n      break;\n    }\n  }\n\n  return widths;\n}\n\nexport function setColumnWidthInsideParentGroup<TState extends CominsColumnWidthState>(\n  state: TState,\n  columnId: string,\n  width: number,\n) {\n  const group = state.columnGroups.find((candidate) => candidate.children.includes(columnId));\n\n  if (!group || state.columnGroupState[group.id]?.hidden === true) {\n    return setColumnWidth(state, columnId, width);\n  }\n\n  const childColumns = group.children\n    .map((childId) => state.columns.find((column) => column.id === childId))\n    .filter((column): column is CominsWidthColumn => Boolean(column))\n    .filter((column) => state.columnState[column.id]?.hidden !== true);\n  const targetColumn = childColumns.find((column) => column.id === columnId);\n\n  if (!targetColumn) {\n    return setColumnWidth(state, columnId, width);\n  }\n\n  const siblingColumns = childColumns.filter((column) => column.id !== columnId);\n\n  if (siblingColumns.length === 0) {\n    const currentGroupWidth = getRuntimeColumnWidth(state, targetColumn);\n\n    return setColumnWidth(\n      state,\n      columnId,\n      clampColumnWidth(width, getEffectiveColumnMinWidth(targetColumn), Math.min(getEffectiveColumnMaxWidth(targetColumn), currentGroupWidth)),\n    );\n  }\n\n  const currentGroupWidth = childColumns.reduce((sum, column) => sum + getRuntimeColumnWidth(state, column), 0);\n  const siblingMinWidth = siblingColumns.reduce((sum, column) => sum + getEffectiveColumnMinWidth(column), 0);\n  const siblingMaxWidth = siblingColumns.reduce((sum, column) => sum + getEffectiveColumnMaxWidth(column), 0);\n  const minWidth = Math.max(getEffectiveColumnMinWidth(targetColumn), currentGroupWidth - siblingMaxWidth);\n  const maxWidth = Math.max(minWidth, Math.min(getEffectiveColumnMaxWidth(targetColumn), currentGroupWidth - siblingMinWidth));\n  const nextTargetWidth = clampColumnWidth(width, minWidth, maxWidth);\n  const nextSiblingWidths = distributeRuntimeColumnWidths(state, siblingColumns, currentGroupWidth - nextTargetWidth);\n  let next = setColumnWidth(state, columnId, nextTargetWidth);\n\n  siblingColumns.forEach((column, index) => {\n    next = setColumnWidth(next, column.id, nextSiblingWidths[index] ?? getRuntimeColumnWidth(next, column));\n  });\n\n  return next;\n}\n","export type CominsColumnPinned = \"left\" | \"right\";\n\nexport type CominsColumnPinningBlock = {\n  columnIds: readonly string[];\n  columnWidths: readonly number[];\n  id: string;\n  pinned?: CominsColumnPinned;\n};\n\nexport type CominsResolvedPinnedColumn = {\n  boundary?: boolean;\n  offset?: number;\n  pinned?: CominsColumnPinned;\n};\n\nexport type CominsResolvedColumnPinning = {\n  columns: ReadonlyMap<string, CominsResolvedPinnedColumn>;\n  orderedColumnIds: readonly string[];\n};\n\nexport type CominsColumnPinningSpanFragment = CominsResolvedPinnedColumn & {\n  colSpan: number;\n  startIndex: number;\n};\n\nexport function normalizeCominsColumnPinned(value: unknown): CominsColumnPinned | undefined {\n  return value === \"left\" || value === \"right\" ? value : undefined;\n}\n\nexport function resolveCominsColumnPinning(\n  blocks: readonly CominsColumnPinningBlock[],\n  containerWidth: number,\n): CominsResolvedColumnPinning {\n  const left = blocks.filter((block) => block.pinned === \"left\");\n  const center = blocks.filter((block) => block.pinned === undefined);\n  const right = blocks.filter((block) => block.pinned === \"right\");\n  const demotedLeft: CominsColumnPinningBlock[] = [];\n  const demotedRight: CominsColumnPinningBlock[] = [];\n  const effectiveLeft = [...left];\n  const effectiveRight = [...right];\n  const safeContainerWidth = Number.isFinite(containerWidth) ? Math.max(0, containerWidth) : 0;\n  const pinnedBudget = safeContainerWidth < 48 ? 0 : safeContainerWidth - 48;\n  const totalWidth = (current: readonly CominsColumnPinningBlock[]) =>\n    current.reduce(\n      (sum, block) =>\n        sum + block.columnWidths.reduce((blockSum, width) => blockSum + Math.max(0, width), 0),\n      0,\n    );\n\n  while (totalWidth(effectiveLeft) + totalWidth(effectiveRight) > pinnedBudget) {\n    const leftWidth = totalWidth(effectiveLeft);\n    const rightWidth = totalWidth(effectiveRight);\n\n    if (leftWidth > rightWidth && effectiveLeft.length > 0) {\n      demotedLeft.unshift(effectiveLeft.pop()!);\n    } else if (effectiveRight.length > 0) {\n      demotedRight.push(effectiveRight.shift()!);\n    } else if (effectiveLeft.length > 0) {\n      demotedLeft.unshift(effectiveLeft.pop()!);\n    } else {\n      break;\n    }\n  }\n\n  const effectiveBlocks = [\n    ...effectiveLeft,\n    ...demotedLeft,\n    ...center,\n    ...demotedRight,\n    ...effectiveRight,\n  ];\n  const columns = new Map<string, CominsResolvedPinnedColumn>();\n  let leftOffset = 0;\n\n  for (const block of effectiveLeft) {\n    for (let index = 0; index < block.columnIds.length; index += 1) {\n      const columnId = block.columnIds[index]!;\n      columns.set(columnId, { offset: leftOffset, pinned: \"left\" });\n      leftOffset += Math.max(0, block.columnWidths[index] ?? 0);\n    }\n  }\n\n  const lastLeftColumnId = effectiveLeft.at(-1)?.columnIds.at(-1);\n\n  if (lastLeftColumnId) {\n    columns.set(lastLeftColumnId, { ...columns.get(lastLeftColumnId), boundary: true });\n  }\n\n  let rightOffset = 0;\n\n  for (let blockIndex = effectiveRight.length - 1; blockIndex >= 0; blockIndex -= 1) {\n    const block = effectiveRight[blockIndex]!;\n\n    for (let columnIndex = block.columnIds.length - 1; columnIndex >= 0; columnIndex -= 1) {\n      const columnId = block.columnIds[columnIndex]!;\n      columns.set(columnId, { offset: rightOffset, pinned: \"right\" });\n      rightOffset += Math.max(0, block.columnWidths[columnIndex] ?? 0);\n    }\n  }\n\n  const firstRightColumnId = effectiveRight[0]?.columnIds[0];\n\n  if (firstRightColumnId) {\n    columns.set(firstRightColumnId, { ...columns.get(firstRightColumnId), boundary: true });\n  }\n\n  for (const block of [...demotedLeft, ...center, ...demotedRight]) {\n    for (const columnId of block.columnIds) {\n      columns.set(columnId, {});\n    }\n  }\n\n  return {\n    columns,\n    orderedColumnIds: effectiveBlocks.flatMap((block) => [...block.columnIds]),\n  };\n}\n\nexport function getCominsPinnedBlockResizeMaxWidth(\n  blocks: readonly CominsColumnPinningBlock[],\n  resolved: CominsResolvedColumnPinning,\n  blockId: string,\n  containerWidth: number,\n  minimumCenterWidth = 48,\n): number | undefined {\n  const target = blocks.find((block) => block.id === blockId);\n\n  if (\n    !target?.pinned ||\n    target.columnIds.length === 0 ||\n    target.columnIds.some((columnId) => resolved.columns.get(columnId)?.pinned !== target.pinned)\n  ) {\n    return undefined;\n  }\n\n  const otherPinnedWidth = blocks.reduce((total, block) => {\n    if (\n      block.id === target.id ||\n      !block.pinned ||\n      block.columnIds.some((columnId) => resolved.columns.get(columnId)?.pinned !== block.pinned)\n    ) {\n      return total;\n    }\n\n    return total + block.columnWidths.reduce(\n      (blockTotal, width) => blockTotal + (Number.isFinite(width) ? Math.max(0, width) : 0),\n      0,\n    );\n  }, 0);\n  const safeContainerWidth = Number.isFinite(containerWidth) ? Math.max(0, containerWidth) : 0;\n  const safeMinimumCenterWidth = Number.isFinite(minimumCenterWidth)\n    ? Math.max(0, minimumCenterWidth)\n    : 48;\n\n  return Math.max(0, safeContainerWidth - safeMinimumCenterWidth - otherPinnedWidth);\n}\n\nexport function getCominsColumnPinningSpanFragments(\n  resolved: CominsResolvedColumnPinning,\n  startIndex: number,\n  colSpan: number,\n): CominsColumnPinningSpanFragment[] {\n  const endIndex = Math.min(\n    resolved.orderedColumnIds.length,\n    Math.max(startIndex, startIndex + Math.max(1, Math.floor(colSpan))),\n  );\n  const fragments: CominsColumnPinningSpanFragment[] = [];\n\n  for (let index = Math.max(0, startIndex); index < endIndex; index += 1) {\n    const columnId = resolved.orderedColumnIds[index];\n    const pin = columnId ? resolved.columns.get(columnId) ?? {} : {};\n    const previous = fragments.at(-1);\n\n    if (previous && previous.pinned === pin.pinned) {\n      previous.colSpan += 1;\n\n      if (pin.pinned === \"right\") {\n        previous.offset = pin.offset;\n      }\n      continue;\n    }\n\n    fragments.push({\n      boundary: pin.boundary,\n      colSpan: 1,\n      offset: pin.offset,\n      pinned: pin.pinned,\n      startIndex: index,\n    });\n  }\n\n  return fragments;\n}\n","import type {\n  CominsColumnPinned,\n  CominsColumnRuntimeState,\n  CominsColumnGroupRuntimeState,\n  CominsColumnLayout,\n  CominsTableRuntimeColumn,\n  CominsTableRuntimeColumnGroup,\n  CominsTableState,\n  CominsHeaderCell,\n} from \"../model\";\nimport {\n  setColumnWidth,\n} from \"../../column-layout\";\nimport {\n  normalizeCominsColumnPinned,\n} from \"../../column-pinning\";\nimport {\n  findColumn,\n} from \"../state/access\";\nconst COMINS_MIN_COLUMN_WIDTH = 88;\n\nexport function normalizeColumns<TColumn extends { id?: string; field: string }>(columns: readonly TColumn[]) {\n  return columns.map((column) => ({\n    ...column,\n    id: column.id ?? column.field,\n  }));\n}\n\nexport function normalizeColumnGroups<TGroup extends { id: string; children: string[] }>(\n  columns: readonly { id: string }[],\n  columnGroups: readonly TGroup[] = [],\n) {\n  const knownColumnIds = new Set(columns.map((column) => column.id));\n  const usedColumnIds = new Set<string>();\n  const usedGroupIds = new Set<string>();\n  const groups: TGroup[] = [];\n\n  for (const group of columnGroups) {\n    if (usedGroupIds.has(group.id)) {\n      continue;\n    }\n\n    const children = group.children.filter((columnId) => {\n      if (!knownColumnIds.has(columnId) || usedColumnIds.has(columnId)) {\n        return false;\n      }\n\n      usedColumnIds.add(columnId);\n      return true;\n    });\n\n    usedGroupIds.add(group.id);\n\n    if (children.length === 0) {\n      continue;\n    }\n\n    groups.push({\n      ...group,\n      children,\n    });\n  }\n\n  return groups;\n}\n\nexport function normalizeColumnState<TData>(\n  columns: ReadonlyArray<CominsTableRuntimeColumn<TData>>,\n  layout?: Partial<CominsColumnLayout>,\n) {\n  const state: Record<string, CominsColumnRuntimeState> = {};\n\n  for (const column of columns) {\n    state[column.id] = {\n      hidden: layout?.columns?.[column.id]?.hidden ?? column.hidden,\n      pinned: normalizeCominsColumnPinned(\n        layout === undefined ? column.pinned : layout.columns?.[column.id]?.pinned,\n      ),\n      width: layout?.columns?.[column.id]?.width ?? column.width,\n    };\n  }\n\n  return state;\n}\n\nexport function normalizeColumnGroupState(\n  columnGroups: ReadonlyArray<CominsTableRuntimeColumnGroup>,\n  layout?: Partial<CominsColumnLayout>,\n) {\n  const state: Record<string, CominsColumnGroupRuntimeState> = {};\n\n  for (const group of columnGroups) {\n    state[group.id] = {\n      hidden: layout?.groups?.[group.id]?.hidden ?? group.hidden,\n      pinned: normalizeCominsColumnPinned(\n        layout === undefined ? group.pinned : layout.groups?.[group.id]?.pinned,\n      ),\n    };\n  }\n\n  return state;\n}\n\nexport function getColumnGroupIdMap(columnGroups: ReadonlyArray<CominsTableRuntimeColumnGroup>) {\n  const map = new Map<string, string>();\n\n  for (const group of columnGroups) {\n    for (const columnId of group.children) {\n      map.set(columnId, group.id);\n    }\n  }\n\n  return map;\n}\n\nexport function findColumnGroupById(\n  columnGroups: ReadonlyArray<CominsTableRuntimeColumnGroup>,\n  groupId: string,\n) {\n  return columnGroups.find((group) => group.id === groupId);\n}\n\nexport function normalizeColumnOrder<TData>(\n  columns: ReadonlyArray<CominsTableRuntimeColumn<TData>>,\n  layout?: Partial<CominsColumnLayout>,\n  columnGroups: ReadonlyArray<CominsTableRuntimeColumnGroup> = [],\n) {\n  const knownIds = new Set(columns.map((column) => column.id));\n  const ordered = (layout?.order ?? []).filter((id) => knownIds.has(id));\n  const missing = columns.map((column) => column.id).filter((id) => !ordered.includes(id));\n  const flatOrder = [...ordered, ...missing];\n  const columnById = new Map(columns.map((column) => [column.id, column]));\n  const groupIdByColumnId = getColumnGroupIdMap(columnGroups);\n  const groupById = new Map(columnGroups.map((group) => [group.id, group]));\n  const isColumnPinned = (columnId: string) =>\n    !groupIdByColumnId.has(columnId) &&\n    normalizeCominsColumnPinned(\n      layout === undefined\n        ? columnById.get(columnId)?.pinned\n        : layout.columns?.[columnId]?.pinned,\n    ) !== undefined;\n  const isGroupPinned = (groupId: string) =>\n    normalizeCominsColumnPinned(\n      layout === undefined\n        ? groupById.get(groupId)?.pinned\n        : layout.groups?.[groupId]?.pinned,\n    ) !== undefined;\n  type ColumnOrderEntity = {\n    columnIds: string[];\n    key: string;\n    locked: boolean;\n  };\n  const createEntities = (order: readonly string[]) => {\n    const emittedGroups = new Set<string>();\n    const entities: ColumnOrderEntity[] = [];\n\n    for (const columnId of order) {\n      const groupId = groupIdByColumnId.get(columnId);\n\n      if (!groupId) {\n        entities.push({\n          columnIds: [columnId],\n          key: `column:${columnId}`,\n          locked:\n            columnById.get(columnId)?.lockPosition === true ||\n            isColumnPinned(columnId),\n        });\n        continue;\n      }\n\n      if (emittedGroups.has(groupId)) {\n        continue;\n      }\n\n      const group = groupById.get(groupId);\n\n      if (!group) {\n        entities.push({\n          columnIds: [columnId],\n          key: `column:${columnId}`,\n          locked:\n            columnById.get(columnId)?.lockPosition === true ||\n            isColumnPinned(columnId),\n        });\n        continue;\n      }\n\n      const groupChildrenInOrder = order.filter((currentId) => group.children.includes(currentId));\n      entities.push({\n        columnIds: groupChildrenInOrder,\n        key: `group:${groupId}`,\n        locked:\n          group.lockPosition ||\n          isGroupPinned(groupId) ||\n          groupChildrenInOrder.some((currentId) => columnById.get(currentId)?.lockPosition === true),\n      });\n      emittedGroups.add(groupId);\n    }\n\n    return entities;\n  };\n  const declaredEntities = createEntities(columns.map((column) => column.id));\n  const proposedEntities = createEntities(flatOrder);\n  const declaredEntityByKey = new Map(declaredEntities.map((entity) => [entity.key, entity]));\n  const declaredSegmentByKey = new Map<string, number>();\n  let segmentCount = 0;\n\n  for (const entity of declaredEntities) {\n    declaredSegmentByKey.set(entity.key, segmentCount);\n\n    if (entity.locked) {\n      segmentCount += 1;\n    }\n  }\n\n  const movableEntitiesBySegment = Array.from(\n    { length: segmentCount + 1 },\n    () => [] as ColumnOrderEntity[],\n  );\n  const proposedEntityByKey = new Map(proposedEntities.map((entity) => [entity.key, entity]));\n\n  for (const entity of proposedEntities) {\n    const declaredEntity = declaredEntityByKey.get(entity.key);\n\n    if (!declaredEntity || declaredEntity.locked) {\n      continue;\n    }\n\n    const segment = declaredSegmentByKey.get(entity.key) ?? 0;\n    movableEntitiesBySegment[segment]?.push(entity);\n  }\n\n  const normalizedEntities: ColumnOrderEntity[] = [];\n  let currentSegment = 0;\n\n  for (const entity of declaredEntities) {\n    if (!entity.locked) {\n      continue;\n    }\n\n    normalizedEntities.push(...(movableEntitiesBySegment[currentSegment] ?? []));\n    normalizedEntities.push(proposedEntityByKey.get(entity.key) ?? entity);\n    currentSegment += 1;\n  }\n\n  normalizedEntities.push(...(movableEntitiesBySegment[currentSegment] ?? []));\n\n  return normalizedEntities.flatMap((entity) => {\n    const declaredEntity = declaredEntityByKey.get(entity.key);\n\n    if (!declaredEntity || entity.columnIds.length === 1) {\n      return entity.columnIds;\n    }\n\n    const lockedChildIds = new Set(\n      declaredEntity.columnIds.filter((columnId) => columnById.get(columnId)?.lockPosition),\n    );\n\n    if (lockedChildIds.size === 0) {\n      return entity.columnIds;\n    }\n\n    const declaredChildSegmentById = new Map<string, number>();\n    let childSegmentCount = 0;\n\n    for (const columnId of declaredEntity.columnIds) {\n      declaredChildSegmentById.set(columnId, childSegmentCount);\n\n      if (lockedChildIds.has(columnId)) {\n        childSegmentCount += 1;\n      }\n    }\n\n    const movableChildrenBySegment = Array.from(\n      { length: childSegmentCount + 1 },\n      () => [] as string[],\n    );\n\n    for (const columnId of entity.columnIds) {\n      if (lockedChildIds.has(columnId)) {\n        continue;\n      }\n\n      const segment = declaredChildSegmentById.get(columnId) ?? 0;\n      movableChildrenBySegment[segment]?.push(columnId);\n    }\n\n    const normalizedChildren: string[] = [];\n    let currentChildSegment = 0;\n\n    for (const columnId of declaredEntity.columnIds) {\n      if (!lockedChildIds.has(columnId)) {\n        continue;\n      }\n\n      normalizedChildren.push(...(movableChildrenBySegment[currentChildSegment] ?? []));\n      normalizedChildren.push(columnId);\n      currentChildSegment += 1;\n    }\n\n    normalizedChildren.push(...(movableChildrenBySegment[currentChildSegment] ?? []));\n    return normalizedChildren;\n  });\n}\n\nexport function setCominsColumnWidth<TData>(\n  state: CominsTableState<TData>,\n  columnId: string,\n  width: number,\n) {\n  return setColumnWidth(state, columnId, width);\n}\n\nexport function setCominsColumnHidden<TData>(\n  state: CominsTableState<TData>,\n  columnId: string,\n  hidden: boolean,\n) {\n  return {\n    ...state,\n    columnState: {\n      ...state.columnState,\n      [columnId]: {\n        ...state.columnState[columnId],\n        hidden,\n      },\n    },\n  };\n}\n\nexport function setCominsColumnGroupHidden<TData>(\n  state: CominsTableState<TData>,\n  groupId: string,\n  hidden: boolean,\n) {\n  if (!findColumnGroupById(state.columnGroups, groupId)) {\n    return state;\n  }\n\n  return {\n    ...state,\n    columnGroupState: {\n      ...state.columnGroupState,\n      [groupId]: {\n        ...state.columnGroupState[groupId],\n        hidden,\n      },\n    },\n  };\n}\n\nexport function getColumnWidth<TData>(\n  state: CominsTableState<TData>,\n  column: CominsTableRuntimeColumn<TData>,\n) {\n  return state.columnState[column.id]?.width ?? column.width ?? 100;\n}\n\nexport function getColumnMinWidth<TData>(column: CominsTableRuntimeColumn<TData>) {\n  return Math.max(COMINS_MIN_COLUMN_WIDTH, column.minWidth ?? COMINS_MIN_COLUMN_WIDTH);\n}\n\nexport function getColumnMaxWidth<TData>(column: CominsTableRuntimeColumn<TData>) {\n  return column.maxWidth ?? Number.POSITIVE_INFINITY;\n}\n\nexport function clampWidth(width: number, minWidth: number, maxWidth: number) {\n  return Math.min(maxWidth, Math.max(minWidth, width));\n}\n\nexport function distributeColumnGroupWidths<TData>(\n  state: CominsTableState<TData>,\n  columns: Array<CominsTableRuntimeColumn<TData>>,\n  targetWidth: number,\n) {\n  const widths = columns.map((column) =>\n    clampWidth(getColumnWidth(state, column), getColumnMinWidth(column), getColumnMaxWidth(column)),\n  );\n  const active = new Set(columns.map((_column, index) => index));\n  const minWidths = columns.map(getColumnMinWidth);\n  const maxWidths = columns.map(getColumnMaxWidth);\n  const boundedTargetWidth = clampWidth(\n    targetWidth,\n    minWidths.reduce((sum, width) => sum + width, 0),\n    maxWidths.reduce((sum, width) => sum + width, 0),\n  );\n\n  while (active.size > 0) {\n    const currentTotal = widths.reduce((sum, width) => sum + width, 0);\n    const delta = boundedTargetWidth - currentTotal;\n\n    if (Math.abs(delta) < 0.001) {\n      break;\n    }\n\n    const activeIndexes = [...active];\n    const activeWeight = activeIndexes.reduce((sum, index) => sum + Math.max(widths[index] ?? 0, 0), 0);\n    let clamped = false;\n\n    for (const index of activeIndexes) {\n      const width = widths[index] ?? 0;\n      const weight = activeWeight > 0 ? width / activeWeight : 1 / activeIndexes.length;\n      const nextWidth = width + delta * weight;\n      const clampedWidth = clampWidth(nextWidth, minWidths[index] ?? 0, maxWidths[index] ?? Number.POSITIVE_INFINITY);\n\n      widths[index] = clampedWidth;\n\n      if (Math.abs(clampedWidth - nextWidth) > 0.001) {\n        active.delete(index);\n        clamped = true;\n      }\n    }\n\n    if (!clamped) {\n      break;\n    }\n  }\n\n  return widths;\n}\n\nexport function setCominsColumnGroupWidth<TData>(\n  state: CominsTableState<TData>,\n  groupId: string,\n  width: number,\n) {\n  const group = findColumnGroupById(state.columnGroups, groupId);\n\n  if (!group || state.columnGroupState[group.id]?.hidden === true) {\n    return state;\n  }\n\n  const childColumns = group.children\n    .map((columnId) => findColumn(state, columnId))\n    .filter((column): column is CominsTableRuntimeColumn<TData> => Boolean(column))\n    .filter((column) => state.columnState[column.id]?.hidden !== true);\n\n  if (childColumns.length === 0) {\n    return state;\n  }\n\n  const widths = distributeColumnGroupWidths(state, childColumns, width);\n  const columnState = { ...state.columnState };\n\n  childColumns.forEach((column, index) => {\n    columnState[column.id] = {\n      ...columnState[column.id],\n      width: widths[index],\n    };\n  });\n\n  return {\n    ...state,\n    columnState,\n  };\n}\n\nexport function doesColumnMoveChangeLockedPositions<TData>(\n  state: CominsTableState<TData>,\n  nextOrder: readonly string[],\n) {\n  const currentIndexByColumnId = new Map(\n    state.columnOrder.map((columnId, index) => [columnId, index] as const),\n  );\n  const nextIndexByColumnId = new Map(\n    nextOrder.map((columnId, index) => [columnId, index] as const),\n  );\n\n  const groupIdByColumnId = getColumnGroupIdMap(state.columnGroups);\n\n  for (const column of state.columns) {\n    if (\n      (\n        column.lockPosition ||\n        (!groupIdByColumnId.has(column.id) && state.columnState[column.id]?.pinned !== undefined)\n      ) &&\n      currentIndexByColumnId.get(column.id) !== nextIndexByColumnId.get(column.id)\n    ) {\n      return true;\n    }\n  }\n\n  for (const group of state.columnGroups) {\n    if (!group.lockPosition && state.columnGroupState[group.id]?.pinned === undefined) {\n      continue;\n    }\n\n    const currentPositions = group.children\n      .map((columnId) => currentIndexByColumnId.get(columnId))\n      .filter((index): index is number => index !== undefined)\n      .sort((left, right) => left - right);\n    const nextPositions = group.children\n      .map((columnId) => nextIndexByColumnId.get(columnId))\n      .filter((index): index is number => index !== undefined)\n      .sort((left, right) => left - right);\n\n    if (\n      currentPositions.length !== nextPositions.length ||\n      currentPositions.some((index, position) => index !== nextPositions[position])\n    ) {\n      return true;\n    }\n  }\n\n  return false;\n}\n\nexport function moveCominsColumn<TData>(\n  state: CominsTableState<TData>,\n  columnId: string,\n  targetIndex: number,\n) {\n  const sourceColumn = findColumn(state, columnId);\n  const sourceGroupId = getColumnGroupIdMap(state.columnGroups).get(columnId);\n\n  if (\n    !sourceColumn ||\n    sourceColumn.lockPosition ||\n    (!sourceGroupId && state.columnState[columnId]?.pinned !== undefined)\n  ) {\n    return state;\n  }\n\n  const groupIdByColumnId = getColumnGroupIdMap(state.columnGroups);\n\n  const current = state.columnOrder.filter((id) => id !== columnId);\n\n  if (current.length === state.columnOrder.length) {\n    return state;\n  }\n\n  const nextIndex = Math.max(0, Math.min(targetIndex, current.length));\n\n  if (sourceGroupId) {\n    const sourceGroup = findColumnGroupById(state.columnGroups, sourceGroupId);\n\n    if (!sourceGroup) {\n      return state;\n    }\n\n    const groupChildrenInCurrent = current.filter((id) => sourceGroup.children.includes(id));\n    const groupStart = current.findIndex((id) => sourceGroup.children.includes(id));\n    const groupEnd = groupStart + groupChildrenInCurrent.length;\n\n    if (nextIndex < groupStart || nextIndex > groupEnd) {\n      return state;\n    }\n  } else if (state.columnGroups.length > 0) {\n    for (const group of state.columnGroups) {\n      const groupChildrenInCurrent = current.filter((id) => group.children.includes(id));\n\n      if (groupChildrenInCurrent.length === 0) {\n        continue;\n      }\n\n      const groupStart = current.findIndex((id) => group.children.includes(id));\n      const groupEnd = groupStart + groupChildrenInCurrent.length;\n\n      if (nextIndex > groupStart && nextIndex < groupEnd) {\n        return state;\n      }\n    }\n  }\n\n  current.splice(nextIndex, 0, columnId);\n\n  if (doesColumnMoveChangeLockedPositions(state, current)) {\n    return state;\n  }\n\n  if (current.every((id, index) => id === state.columnOrder[index])) {\n    return state;\n  }\n\n  return { ...state, columnOrder: current };\n}\n\nexport function moveCominsColumnGroup<TData>(\n  state: CominsTableState<TData>,\n  groupId: string,\n  targetIndex: number,\n) {\n  const group = findColumnGroupById(state.columnGroups, groupId);\n\n  if (\n    !group ||\n    group.lockPosition ||\n    state.columnGroupState[groupId]?.pinned !== undefined\n  ) {\n    return state;\n  }\n\n  const groupChildren = state.columnOrder.filter((id) => group.children.includes(id));\n\n  if (groupChildren.length === 0) {\n    return state;\n  }\n\n  const current = state.columnOrder.filter((id) => !group.children.includes(id));\n  const nextIndex = Math.max(0, Math.min(targetIndex, current.length));\n  const nextOrder = [...current.slice(0, nextIndex), ...groupChildren, ...current.slice(nextIndex)];\n\n  if (doesColumnMoveChangeLockedPositions(state, nextOrder)) {\n    return state;\n  }\n\n  if (nextOrder.every((id, index) => id === state.columnOrder[index])) {\n    return state;\n  }\n\n  return { ...state, columnOrder: nextOrder };\n}\n\nexport function serializeCominsColumnLayout<TData>(state: CominsTableState<TData>): CominsColumnLayout {\n  const groups =\n    state.columnGroups.length === 0\n      ? undefined\n      : Object.fromEntries(state.columnGroups.map((group) => [group.id, { ...state.columnGroupState[group.id] }]));\n\n  return {\n    columns: { ...state.columnState },\n    ...(groups ? { groups } : {}),\n    order: [...state.columnOrder],\n  };\n}\n\nexport function applyCominsColumnLayout<TData>(state: CominsTableState<TData>, layout: CominsColumnLayout) {\n  return {\n    ...state,\n    columnOrder: normalizeColumnOrder(state.columns, layout, state.columnGroups),\n    columnGroupState: normalizeColumnGroupState(state.columnGroups, layout),\n    columnState: normalizeColumnState(state.columns, layout),\n  };\n}\n\nexport function getCominsVisibleColumns<TData>(state: CominsTableState<TData>) {\n  const groupIdByColumnId = getColumnGroupIdMap(state.columnGroups);\n  const groupById = new Map(state.columnGroups.map((group) => [group.id, group]));\n  const emittedGroups = new Set<string>();\n  const blocks: Array<{\n    columns: Array<CominsTableRuntimeColumn<TData>>;\n    pinned?: CominsColumnPinned;\n  }> = [];\n\n  for (const columnId of state.columnOrder) {\n    const column = findColumn(state, columnId);\n\n    if (!column || state.columnState[column.id]?.hidden === true) {\n      continue;\n    }\n\n    const groupId = groupIdByColumnId.get(column.id);\n\n    if (!groupId) {\n      blocks.push({ columns: [column], pinned: state.columnState[column.id]?.pinned });\n      continue;\n    }\n\n    if (emittedGroups.has(groupId) || state.columnGroupState[groupId]?.hidden === true) {\n      continue;\n    }\n\n    const group = groupById.get(groupId);\n\n    if (!group) {\n      continue;\n    }\n\n    const columns = state.columnOrder\n      .filter((currentId) => group.children.includes(currentId))\n      .map((currentId) => findColumn(state, currentId))\n      .filter((current): current is CominsTableRuntimeColumn<TData> =>\n        Boolean(current) && state.columnState[current!.id]?.hidden !== true,\n      );\n\n    if (columns.length > 0) {\n      blocks.push({ columns, pinned: state.columnGroupState[groupId]?.pinned });\n    }\n\n    emittedGroups.add(groupId);\n  }\n\n  return [\"left\", undefined, \"right\"].flatMap((pinned) =>\n    blocks\n      .filter((block) => block.pinned === pinned)\n      .flatMap((block) => block.columns),\n  );\n}\n\nexport function getCominsHeaderRows<TData>(state: CominsTableState<TData>): Array<Array<CominsHeaderCell<TData>>> {\n  const visibleColumns = getCominsVisibleColumns(state);\n\n  if (state.columnGroups.length === 0) {\n    return [\n      visibleColumns.map((column) => ({\n        colSpan: 1,\n        column,\n        columnId: column.id,\n        kind: \"column\",\n        rowSpan: 1,\n      })),\n    ];\n  }\n\n  const visibleColumnIds = new Set(visibleColumns.map((column) => column.id));\n  const groupIdByColumnId = getColumnGroupIdMap(state.columnGroups);\n  const groupById = new Map(state.columnGroups.map((group) => [group.id, group]));\n  const emittedGroups = new Set<string>();\n  const parentRow: Array<CominsHeaderCell<TData>> = [];\n  const childRow: Array<CominsHeaderCell<TData>> = [];\n\n  for (const column of visibleColumns) {\n    const columnId = column.id;\n\n    const groupId = groupIdByColumnId.get(columnId);\n\n    if (!groupId) {\n      parentRow.push({\n        colSpan: 1,\n        column,\n        columnId: column.id,\n        kind: \"column\",\n        rowSpan: 2,\n      });\n      continue;\n    }\n\n    if (emittedGroups.has(groupId)) {\n      continue;\n    }\n\n    const group = groupById.get(groupId);\n\n    if (!group) {\n      continue;\n    }\n\n    const visibleGroupColumns = visibleColumns.filter((currentColumn) =>\n      group.children.includes(currentColumn.id),\n    );\n\n    if (visibleGroupColumns.length === 0) {\n      emittedGroups.add(groupId);\n      continue;\n    }\n\n    parentRow.push({\n      colSpan: visibleGroupColumns.length,\n      group,\n      groupId,\n      kind: \"group\",\n      rowSpan: 1,\n    });\n    childRow.push(\n      ...visibleGroupColumns.map((currentColumn) => ({\n        colSpan: 1 as const,\n        column: currentColumn,\n        columnId: currentColumn.id,\n        groupId,\n        kind: \"column\" as const,\n        rowSpan: 1 as const,\n      })),\n    );\n    emittedGroups.add(groupId);\n  }\n\n  return [parentRow, childRow];\n}\n","import type {\n  CominsRowId,\n  CominsSelectionState,\n  CominsCellAddress,\n  CominsCellRange,\n  CominsRowSelectionOptions,\n  CominsCellSelectionOptions,\n  CominsTableState,\n} from \"../model\";\nimport {\n  getCominsVisibleColumns,\n} from \"../layout/columns\";\n\nexport function createEmptySelection(): CominsSelectionState {\n  return {\n    cell: null,\n    cells: [],\n    range: null,\n    rowIds: [],\n  };\n}\n\nexport function getCellRangeBounds<TData>(\n  state: CominsTableState<TData>,\n  range: CominsCellRange,\n  rowIds: readonly CominsRowId[] = state.rowIds,\n) {\n  const visibleColumns = getCominsVisibleColumns(state);\n  const anchorRowIndex = rowIds.indexOf(range.anchor.rowId);\n  const focusRowIndex = rowIds.indexOf(range.focus.rowId);\n  const anchorColumnIndex = visibleColumns.findIndex((column) => column.id === range.anchor.columnId);\n  const focusColumnIndex = visibleColumns.findIndex((column) => column.id === range.focus.columnId);\n\n  if (anchorRowIndex < 0 || focusRowIndex < 0 || anchorColumnIndex < 0 || focusColumnIndex < 0) {\n    return null;\n  }\n\n  return {\n    columnEnd: Math.max(anchorColumnIndex, focusColumnIndex),\n    columnStart: Math.min(anchorColumnIndex, focusColumnIndex),\n    rowEnd: Math.max(anchorRowIndex, focusRowIndex),\n    rowIds,\n    rowStart: Math.min(anchorRowIndex, focusRowIndex),\n    visibleColumns,\n  };\n}\n\nexport function selectRow<TData>(\n  state: CominsTableState<TData>,\n  rowId: CominsRowId,\n  options: CominsRowSelectionOptions = {},\n) {\n  const current = state.selection.rowIds;\n  const selected = current.includes(rowId);\n  const rowIds = options.multi\n    ? options.toggle && selected\n      ? current.filter((id) => id !== rowId)\n      : selected\n        ? current\n        : [...current, rowId]\n    : options.toggle && selected\n      ? []\n      : [rowId];\n\n  return {\n    ...state,\n    selection: {\n      ...state.selection,\n      rowIds,\n    },\n  };\n}\n\nexport function selectRows<TData>(state: CominsTableState<TData>, rowIds: readonly CominsRowId[]) {\n  return {\n    ...state,\n    selection: {\n      ...state.selection,\n      rowIds: [...rowIds],\n    },\n  };\n}\n\nexport function areCellAddressesEqual(left: CominsCellAddress, right: CominsCellAddress) {\n  return left.rowId === right.rowId && left.columnId === right.columnId;\n}\n\nexport function selectCell<TData>(\n  state: CominsTableState<TData>,\n  cell: CominsCellAddress,\n  options: CominsCellSelectionOptions = {},\n) {\n  const current = state.selection.cells ?? (state.selection.cell ? [state.selection.cell] : []);\n  const selected = current.some((candidate) => areCellAddressesEqual(candidate, cell));\n  const cells = options.multi\n    ? options.toggle && selected\n      ? current.filter((candidate) => !areCellAddressesEqual(candidate, cell))\n      : selected\n        ? current\n        : [...current, cell]\n    : options.toggle && selected\n      ? []\n      : [cell];\n  const activeCell = cells.some((candidate) => areCellAddressesEqual(candidate, cell))\n    ? cell\n    : (cells.at(-1) ?? null);\n\n  return {\n    ...state,\n    selection: {\n      ...state.selection,\n      cell: activeCell,\n      cells,\n      range: null,\n    },\n  };\n}\n\nexport function selectCellRange<TData>(state: CominsTableState<TData>, range: CominsCellRange) {\n  return {\n    ...state,\n    selection: {\n      ...state.selection,\n      cell: range.focus,\n      cells: [],\n      range,\n    },\n  };\n}\n\nexport function clearCominsCellRange<TData>(state: CominsTableState<TData>) {\n  return {\n    ...state,\n    selection: {\n      ...state.selection,\n      range: null,\n    },\n  };\n}\n\nexport function clearCominsSelection<TData>(state: CominsTableState<TData>) {\n  return {\n    ...state,\n    selection: createEmptySelection(),\n  };\n}\n\nexport function isCominsRowSelected<TData>(state: Pick<CominsTableState<TData>, \"selection\">, rowId: CominsRowId) {\n  return state.selection.rowIds.includes(rowId);\n}\n\nexport function isCominsCellSelected<TData>(state: Pick<CominsTableState<TData>, \"selection\">, cell: CominsCellAddress) {\n  const selectedCells = state.selection.cells;\n\n  if (selectedCells && selectedCells.length > 0) {\n    return selectedCells.some((candidate) => areCellAddressesEqual(candidate, cell));\n  }\n\n  return state.selection.cell !== null && areCellAddressesEqual(state.selection.cell, cell);\n}\n\nexport function getCominsSelectedCellRange<TData>(\n  state: CominsTableState<TData>,\n  range: CominsCellRange | null = state.selection.range,\n  rowIds: readonly CominsRowId[] = state.rowIds,\n) {\n  if (!range) {\n    return [];\n  }\n\n  const visibleColumns = getCominsVisibleColumns(state);\n  const bounds = getCellRangeBounds(state, range, rowIds);\n\n  if (!bounds) {\n    return [];\n  }\n\n  const cells: CominsCellAddress[] = [];\n\n  for (let rowIndex = bounds.rowStart; rowIndex <= bounds.rowEnd; rowIndex += 1) {\n    const rowId = bounds.rowIds[rowIndex];\n\n    if (rowId === undefined) {\n      continue;\n    }\n\n    for (let columnIndex = bounds.columnStart; columnIndex <= bounds.columnEnd; columnIndex += 1) {\n      const column = visibleColumns[columnIndex];\n\n      if (column) {\n        cells.push({ columnId: column.id, rowId });\n      }\n    }\n  }\n\n  return cells;\n}\n\nexport function isCominsCellInSelectedRange<TData>(\n  state: CominsTableState<TData>,\n  cell: CominsCellAddress,\n  rowIds: readonly CominsRowId[] = state.rowIds,\n) {\n  return getCominsSelectedCellRange(state, state.selection.range, rowIds).some(\n    (selected) => selected.rowId === cell.rowId && selected.columnId === cell.columnId,\n  );\n}\n","import type {\n  CominsRowId,\n  CominsSortState,\n  CominsSortModel,\n  CominsPaginationState,\n  CominsRowUpdate,\n  CominsVirtualRowsOptions,\n  CominsVirtualRows,\n  CominsTableRuntimeColumn,\n  CominsTableState,\n  CominsTableStateInput,\n} from \"../model\";\nimport {\n  normalizeColumns,\n  normalizeColumnGroups,\n  normalizeColumnState,\n  normalizeColumnGroupState,\n  normalizeColumnOrder,\n} from \"../layout/columns\";\nimport {\n  createEmptySelection,\n} from \"../selection/state\";\nimport {\n  findRowIndex,\n  findColumn,\n  getNestedFieldValue,\n} from \"./access\";\n\nexport type CominsRowGroupMoveOptions<TData> = {\n  getRowGroupId: (row: TData, dataIndex: number) => CominsRowId;\n  setRowGroupId?: (params: {\n    fromGroupId: CominsRowId;\n    row: TData;\n    rowId: CominsRowId;\n    toGroupId: CominsRowId;\n  }) => TData;\n  sourceRowId: CominsRowId;\n  targetGroupId: CominsRowId;\n  targetRowId?: CominsRowId;\n};\n\nexport function defaultGetRowId<TData>(_row: TData, index: number) {\n  return index;\n}\n\nexport function useRowsReference<TData>(rows: readonly TData[]) {\n  return rows as TData[];\n}\n\nexport function areRowIdsEqual(left: readonly CominsRowId[], right: readonly CominsRowId[]) {\n  return left.length === right.length && left.every((id, index) => id === right[index]);\n}\n\nexport function withRows<TData>(\n  state: CominsTableState<TData>,\n  rows: TData[],\n  options: { resetSelection?: boolean } = {},\n): CominsTableState<TData> {\n  const rowIds = rows.map(state.getRowId);\n  const shouldResetSelection = options.resetSelection === true || !areRowIdsEqual(state.rowIds, rowIds);\n\n  return {\n    ...state,\n    rowIds,\n    rows,\n    selection: shouldResetSelection ? createEmptySelection() : state.selection,\n  };\n}\n\nexport function areSortModelsEqual(left: CominsSortModel, right: CominsSortModel) {\n  return (\n    left.length === right.length &&\n    left.every(\n      (rule, index) => rule.columnId === right[index]?.columnId && rule.direction === right[index]?.direction,\n    )\n  );\n}\n\nexport function normalizeSortModel<TData>(\n  columns: ReadonlyArray<CominsTableRuntimeColumn<TData>>,\n  sortModel: CominsSortModel,\n): CominsSortState[] {\n  const sortableColumnIds = new Set(columns.filter((column) => Boolean(column.sort)).map((column) => column.id));\n  const usedColumnIds = new Set<string>();\n  const normalized: CominsSortState[] = [];\n\n  for (const rule of sortModel) {\n    if (\n      !sortableColumnIds.has(rule.columnId) ||\n      usedColumnIds.has(rule.columnId) ||\n      (rule.direction !== \"asc\" && rule.direction !== \"desc\")\n    ) {\n      continue;\n    }\n\n    usedColumnIds.add(rule.columnId);\n    normalized.push({ columnId: rule.columnId, direction: rule.direction });\n  }\n\n  return normalized;\n}\n\nexport function defaultCompare(left: unknown, right: unknown) {\n  if (typeof left === \"number\" && typeof right === \"number\") {\n    return left - right;\n  }\n\n  return String(left ?? \"\").localeCompare(String(right ?? \"\"));\n}\n\nexport function createCominsTableState<TData>({\n  columnLayout,\n  columnGroups,\n  columns,\n  getRowId = defaultGetRowId,\n  pagination,\n  rows,\n  showHeader = true,\n  sort = null,\n  sortModel,\n}: CominsTableStateInput<TData>): CominsTableState<TData> {\n  const nextRows = useRowsReference(rows);\n  const nextColumns = normalizeColumns(columns);\n  const nextColumnGroups = normalizeColumnGroups(nextColumns, columnGroups);\n  const nextSortModel = normalizeSortModel(nextColumns, sortModel ?? (sort ? [sort] : []));\n\n  return {\n    columnOrder: normalizeColumnOrder(nextColumns, columnLayout, nextColumnGroups),\n    columnGroups: nextColumnGroups,\n    columnGroupState: normalizeColumnGroupState(nextColumnGroups, columnLayout),\n    columns: nextColumns,\n    columnState: normalizeColumnState(nextColumns, columnLayout),\n    getRowId,\n    pagination: {\n      pageIndex: pagination?.pageIndex ?? 0,\n      pageSize: pagination?.pageSize ?? Math.max(nextRows.length, 1),\n    },\n    rowIds: nextRows.map(getRowId),\n    rows: nextRows,\n    selection: createEmptySelection(),\n    showHeader,\n    sort: nextSortModel[0] ?? null,\n    sortModel: nextSortModel,\n  };\n}\n\nexport function queryCominsRows<TData>(\n  state: Pick<CominsTableState<TData>, \"rows\">,\n  predicate?: (row: TData, index: number) => boolean,\n) {\n  return predicate ? state.rows.filter(predicate) : [...state.rows];\n}\n\nexport function replaceCominsRows<TData>(state: CominsTableState<TData>, rows: readonly TData[]) {\n  return withRows(state, useRowsReference(rows), { resetSelection: true });\n}\n\nexport function addCominsRows<TData>(state: CominsTableState<TData>, rows: readonly TData[]) {\n  return withRows(state, [...state.rows, ...rows]);\n}\n\nexport function updateCominsRows<TData>(\n  state: CominsTableState<TData>,\n  updates: ReadonlyArray<CominsRowUpdate<TData>>,\n) {\n  const updateMap = new Map(updates.map((update) => [update.id, update.patch]));\n  const rows = state.rows.map((row, index) => {\n    const rowId = state.rowIds[index];\n    const patch = rowId === undefined ? undefined : updateMap.get(rowId);\n\n    if (!patch) {\n      return row;\n    }\n\n    return typeof patch === \"function\" ? patch(row) : { ...row, ...patch };\n  });\n\n  return withRows(state, rows);\n}\n\nexport function deleteCominsRows<TData>(state: CominsTableState<TData>, rowIds: readonly CominsRowId[]) {\n  const deleteIds = new Set(rowIds);\n\n  return withRows(\n    state,\n    state.rows.filter((_row, index) => {\n      const rowId = state.rowIds[index];\n\n      return rowId === undefined || !deleteIds.has(rowId);\n    }),\n  );\n}\n\nexport function setCominsHeaderVisible<TData>(state: CominsTableState<TData>, showHeader: boolean) {\n  return {\n    ...state,\n    showHeader,\n  };\n}\n\nexport function setCominsPagination<TData>(\n  state: CominsTableState<TData>,\n  pagination: Partial<CominsPaginationState>,\n) {\n  return {\n    ...state,\n    pagination: {\n      pageIndex: pagination.pageIndex ?? state.pagination.pageIndex,\n      pageSize: pagination.pageSize ?? state.pagination.pageSize,\n    },\n  };\n}\n\nexport function setCominsSortState<TData>(\n  state: CominsTableState<TData>,\n  sort: CominsSortState | null,\n) {\n  return setCominsSortModel(state, sort ? [sort] : []);\n}\n\nexport function setCominsSortModel<TData>(\n  state: CominsTableState<TData>,\n  sortModel: CominsSortModel,\n) {\n  const nextSortModel = normalizeSortModel(state.columns, sortModel);\n  const nextSort = nextSortModel[0] ?? null;\n\n  if (areSortModelsEqual(state.sortModel, nextSortModel)) {\n    return state;\n  }\n\n  return {\n    ...state,\n    sort: nextSort,\n    sortModel: nextSortModel,\n  };\n}\n\nexport function clearCominsSortState<TData>(state: CominsTableState<TData>) {\n  return setCominsSortModel(state, []);\n}\n\nexport function getCominsSortedRowIndexes<TData>(\n  state: CominsTableState<TData>,\n  sourceIndexes: readonly number[] = state.rows.map((_row, index) => index),\n) {\n  const indexes = [...sourceIndexes];\n\n  if (state.sortModel.length === 0) {\n    return indexes;\n  }\n\n  return [...indexes].sort((leftIndex, rightIndex) => {\n    const leftRow = state.rows[leftIndex]!;\n    const rightRow = state.rows[rightIndex]!;\n\n    for (const rule of state.sortModel) {\n      const column = findColumn(state, rule.columnId);\n\n      if (!column?.sort) {\n        continue;\n      }\n\n      const leftValue = getCominsCellValue(state, leftRow, column.id);\n      const rightValue = getCominsCellValue(state, rightRow, column.id);\n      const result =\n        typeof column.sort === \"function\"\n          ? column.sort(leftValue, rightValue, leftRow, rightRow)\n          : defaultCompare(leftValue, rightValue);\n\n      if (result !== 0) {\n        return rule.direction === \"desc\" ? result * -1 : result;\n      }\n    }\n\n    return leftIndex - rightIndex;\n  });\n}\n\nexport function sortCominsRows<TData>(\n  state: CominsTableState<TData>,\n  sort: CominsSortState | null,\n) {\n  const sortedState = setCominsSortState(state, sort);\n  const indexes = getCominsSortedRowIndexes(sortedState);\n  const rows = indexes.map((index) => sortedState.rows[index]!);\n\n  return withRows(sortedState, rows);\n}\n\nexport function getCominsPageRows<TData>(\n  state: CominsTableState<TData>,\n  pagination: Partial<CominsPaginationState> = {},\n) {\n  const pageIndex = pagination.pageIndex ?? state.pagination.pageIndex;\n  const pageSize = pagination.pageSize ?? state.pagination.pageSize;\n  const start = Math.max(0, pageIndex) * Math.max(1, pageSize);\n  const indexes = getCominsSortedRowIndexes(state).slice(start, start + Math.max(1, pageSize));\n\n  return indexes.map((index) => state.rows[index]!);\n}\n\nexport function getCominsVirtualRows<TData>(\n  state: CominsTableState<TData>,\n  { overscan = 2, rowHeight, scrollTop, viewportHeight }: CominsVirtualRowsOptions,\n): CominsVirtualRows<TData> {\n  const safeRowHeight = Math.max(1, rowHeight);\n  const rowIndexes = getCominsSortedRowIndexes(state);\n  const totalRows = rowIndexes.length;\n  const totalHeight = totalRows * safeRowHeight;\n  const startIndex = Math.max(0, Math.floor(Math.max(0, scrollTop) / safeRowHeight) - Math.max(0, overscan));\n  const endIndex = Math.min(\n    totalRows,\n    Math.ceil((Math.max(0, scrollTop) + Math.max(0, viewportHeight)) / safeRowHeight) + Math.max(0, overscan),\n  );\n  const topSpacerHeight = startIndex * safeRowHeight;\n\n  return {\n    bottomSpacerHeight: Math.max(0, totalHeight - topSpacerHeight - (endIndex - startIndex) * safeRowHeight),\n    endIndex,\n    rows: rowIndexes.slice(startIndex, endIndex).map((index) => state.rows[index]!),\n    startIndex,\n    topSpacerHeight,\n    totalHeight,\n  };\n}\n\nexport function moveCominsRow<TData>(\n  state: CominsTableState<TData>,\n  rowId: CominsRowId,\n  targetIndex: number,\n) {\n  const currentIndex = findRowIndex(state, rowId);\n\n  if (currentIndex < 0) {\n    return state;\n  }\n\n  const rows = [...state.rows];\n  const [row] = rows.splice(currentIndex, 1);\n\n  if (row === undefined) {\n    return state;\n  }\n\n  rows.splice(Math.max(0, Math.min(targetIndex, rows.length)), 0, row);\n\n  return withRows(state, rows);\n}\n\nexport function moveCominsRowToGroup<TData>(\n  state: CominsTableState<TData>,\n  options: CominsRowGroupMoveOptions<TData>,\n) {\n  const sourceIndex = findRowIndex(state, options.sourceRowId);\n  const targetRowIndex = options.targetRowId === undefined\n    ? -1\n    : findRowIndex(state, options.targetRowId);\n\n  if (\n    sourceIndex < 0 ||\n    options.targetRowId === options.sourceRowId ||\n    (options.targetRowId !== undefined && targetRowIndex < 0)\n  ) {\n    return state;\n  }\n\n  const sourceRow = state.rows[sourceIndex];\n\n  if (sourceRow === undefined) {\n    return state;\n  }\n\n  const fromGroupId = options.getRowGroupId(sourceRow, sourceIndex);\n  const membershipChanged = fromGroupId !== options.targetGroupId;\n\n  if (membershipChanged && typeof options.setRowGroupId !== \"function\") {\n    return state;\n  }\n\n  if (targetRowIndex >= 0) {\n    const targetRow = state.rows[targetRowIndex];\n\n    if (\n      targetRow === undefined ||\n      options.getRowGroupId(targetRow, targetRowIndex) !== options.targetGroupId\n    ) {\n      return state;\n    }\n  }\n\n  const movedRow = membershipChanged\n    ? options.setRowGroupId!({\n        fromGroupId,\n        row: sourceRow,\n        rowId: options.sourceRowId,\n        toGroupId: options.targetGroupId,\n      })\n    : sourceRow;\n  const rows = [...state.rows];\n  rows.splice(sourceIndex, 1);\n  let targetIndex: number;\n\n  if (options.targetRowId !== undefined) {\n    targetIndex = Math.max(0, Math.min(targetRowIndex, rows.length));\n  } else {\n    let lastTargetIndex = -1;\n\n    rows.forEach((row, index) => {\n      if (options.getRowGroupId(row, index) === options.targetGroupId) {\n        lastTargetIndex = index;\n      }\n    });\n    targetIndex = lastTargetIndex < 0 ? rows.length : lastTargetIndex + 1;\n  }\n\n  rows.splice(targetIndex, 0, movedRow);\n\n  return withRows(state, rows);\n}\n\nexport function getCominsCellValue<TData>(\n  state: { columns: readonly { id: string; field: string }[] },\n  row: TData,\n  columnId: string,\n) {\n  const column = findColumn(state, columnId);\n\n  return column ? getNestedFieldValue(row, column.field) : undefined;\n}\n","import type {\n  CominsTableState, CominsRowId, CominsTableRuntimeColumn,\n  CominsCellComponentPayload, CominsClipboardGuard, CominsCellAddress, CominsCopiedCell,\n} from \"../model\";\nimport { findColumn, findRowIndex } from \"../state/access\";\nimport { getCominsCellValue, updateCominsRows } from \"../state/table\";\n\nexport function setNestedFieldValue<TData>(row: TData, field: string, value: unknown): TData {\n  if (!row || typeof row !== \"object\") {\n    return row;\n  }\n\n  const keys = field.split(\".\");\n  const [firstKey] = keys;\n\n  if (!firstKey) {\n    return row;\n  }\n\n  if (keys.length === 1) {\n    return { ...row, [firstKey]: value };\n  }\n\n  const root = { ...(row as Record<string, unknown>) };\n  let current: Record<string, unknown> = root;\n\n  keys.slice(0, -1).forEach((key, index) => {\n    const nextKey = keys[index + 1];\n    const existing = current[key];\n    const next =\n      existing && typeof existing === \"object\" && !Array.isArray(existing)\n        ? { ...(existing as Record<string, unknown>) }\n        : {};\n\n    current[key] = next;\n\n    if (nextKey) {\n      current = next;\n    }\n  });\n\n  current[keys.at(-1)!] = value;\n\n  return root as TData;\n}\n\nexport function createCellComponentParams<TData>(\n  state: CominsTableState<TData>,\n  row: TData,\n  rowId: CominsRowId,\n  column: CominsTableRuntimeColumn<TData>,\n  rowIndex = state.rowIds.indexOf(rowId),\n): CominsCellComponentPayload<TData> {\n  return {\n    column: {\n      definition: column,\n      field: column.field,\n      id: column.id,\n      index: state.columns.findIndex((current) => current.id === column.id),\n      label: column.label,\n    },\n    row: {\n      data: row,\n      dataIndex: rowIndex,\n      disabled: false,\n      id: rowId,\n      index: rowIndex,\n      selected: state.selection.rowIds.includes(rowId),\n    },\n    selection: {\n      selectedRowCount: state.selection.rowIds.length,\n    },\n    value: getCominsCellValue(state, row, column.id),\n  };\n}\n\nexport function resolveGuard<TData>(\n  guard: CominsClipboardGuard<TData> | undefined,\n  params: CominsCellComponentPayload<TData>,\n) {\n  if (guard === undefined) {\n    return true;\n  }\n\n  return typeof guard === \"boolean\" ? guard : guard(params);\n}\n\nexport function canUseCellClipboard<TData>(\n  state: CominsTableState<TData>,\n  row: TData | undefined,\n  rowId: CominsRowId,\n  column: CominsTableRuntimeColumn<TData>,\n  kind: \"copy\" | \"paste\",\n  rowIndex = state.rowIds.indexOf(rowId),\n) {\n  if (row === undefined) {\n    return false;\n  }\n\n  const params = createCellComponentParams(state, row, rowId, column, rowIndex);\n  const props = column.cell;\n\n  if (props?.disabled !== undefined && resolveGuard(props.disabled, params) === true) {\n    return false;\n  }\n\n  return resolveGuard(kind === \"copy\" ? props?.copyable : props?.pasteable, params);\n}\n\nexport function isCominsCellDisabled<TData>(\n  state: CominsTableState<TData>, row: TData, rowId: CominsRowId, column: CominsTableRuntimeColumn<TData>,\n) {\n  const disabled = column.cell?.disabled;\n  return disabled !== undefined && resolveGuard(disabled, createCellComponentParams(state, row, rowId, column)) === true;\n}\n\nexport function copyCominsCell<TData>(\n  state: CominsTableState<TData>,\n  { columnId, rowId }: CominsCellAddress,\n): CominsCopiedCell | null {\n  const row = state.rows[findRowIndex(state, rowId)];\n  const column = findColumn(state, columnId);\n\n  if (!column || !canUseCellClipboard(state, row, rowId, column, \"copy\")) {\n    return null;\n  }\n\n  const value = getCominsCellValue(state, row!, columnId);\n\n  return {\n    kind: \"cell\",\n    text: value == null ? \"\" : String(value),\n    value,\n  };\n}\n\nexport function pasteCominsCell<TData>(\n  state: CominsTableState<TData>,\n  { columnId, rowId }: CominsCellAddress,\n  copied: CominsCopiedCell | null,\n) {\n  const column = findColumn(state, columnId);\n  const row = state.rows[findRowIndex(state, rowId)];\n\n  if (!copied || !column || !canUseCellClipboard(state, row, rowId, column, \"paste\")) {\n    return state;\n  }\n\n  return updateCominsRows(state, [\n    {\n      id: rowId,\n      patch: (currentRow) => setNestedFieldValue(currentRow, column.field, copied.value),\n    },\n  ]);\n}\n","import type {\n  CominsTableState, CominsRowId, CominsTableRuntimeColumn, CominsCopiedRow, CominsPasteRowOptions,\n  CominsCellAddress, CominsCellRange, CominsCopiedCellRange, CominsCopiedCellRangeCell, CominsFillCellRangeOptions,\n} from \"../model\";\nimport { addCominsRows, updateCominsRows, withRows, getCominsCellValue } from \"../state/table\";\nimport { findRowIndex, getNestedFieldValue } from \"../state/access\";\nimport { getCominsVisibleColumns } from \"../layout/columns\";\nimport { getCellRangeBounds } from \"../selection/state\";\nimport { parseCominsClipboardText, MAX_CLIPBOARD_CELLS } from \"../../clipboard-text\";\nimport { canUseCellClipboard, createCellComponentParams, setNestedFieldValue } from \"./cells\";\n\nfunction assignGeneratedRowId<TData>(row: TData, rowId: CominsRowId) {\n  if (row && typeof row === \"object\" && \"id\" in row) {\n    return { ...row, id: rowId } as TData;\n  }\n\n  return row;\n}\n\nfunction createCopiedRowId(existingIds: readonly CominsRowId[], sourceRowId: CominsRowId) {\n  let index = 1;\n  let nextId = `${String(sourceRowId)}-copy-${index}`;\n  const ids = new Set(existingIds.map(String));\n\n  while (ids.has(nextId)) {\n    index += 1;\n    nextId = `${String(sourceRowId)}-copy-${index}`;\n  }\n\n  return nextId;\n}\n\nexport function copyCominsRow<TData>(state: CominsTableState<TData>, rowId: CominsRowId): CominsCopiedRow<TData> {\n  const row = state.rows[findRowIndex(state, rowId)];\n\n  if (row === undefined) {\n    throw new Error(`Cannot copy missing row: ${String(rowId)}`);\n  }\n\n  return {\n    kind: \"row\",\n    row,\n    text: JSON.stringify(row),\n  };\n}\n\nexport function pasteCominsRow<TData>(\n  state: CominsTableState<TData>,\n  copied: CominsCopiedRow<TData>,\n  options: CominsPasteRowOptions<TData>,\n) {\n  if (options.mode === \"append\") {\n    const rowId = options.getNewRowId?.(copied.row);\n    const row = rowId === undefined ? copied.row : assignGeneratedRowId(copied.row, rowId);\n\n    return addCominsRows(state, [row]);\n  }\n\n  if (options.mode === \"insert-after\") {\n    const targetIndex = findRowIndex(state, options.targetRowId);\n\n    if (targetIndex < 0) {\n      return state;\n    }\n\n    const sourceRowId = state.getRowId(copied.row, targetIndex);\n    const rowId = options.getPastedRowId?.(copied.row) ?? createCopiedRowId(state.rowIds, sourceRowId);\n    const row = assignGeneratedRowId(copied.row, rowId);\n    const rows = [...state.rows];\n    rows.splice(targetIndex + 1, 0, row);\n\n    return withRows(state, rows);\n  }\n\n  return updateCominsRows(state, [\n    {\n      id: options.targetRowId,\n      patch: assignGeneratedRowId(copied.row, options.targetRowId) as Partial<TData>,\n    },\n  ]);\n}\n\nexport function copyCominsCellRange<TData>(\n  state: CominsTableState<TData>,\n  range: CominsCellRange | null = state.selection.range,\n  rowIds: readonly CominsRowId[] = state.rowIds,\n): CominsCopiedCellRange | null {\n  if (!range) {\n    return null;\n  }\n\n  const bounds = getCellRangeBounds(state, range, rowIds);\n\n  if (!bounds) {\n    return null;\n  }\n\n  const copiedRows: CominsCopiedCellRangeCell[][] = [];\n\n  for (let rowIndex = bounds.rowStart; rowIndex <= bounds.rowEnd; rowIndex += 1) {\n    const rowId = bounds.rowIds[rowIndex];\n    const dataIndex = rowId === undefined ? -1 : findRowIndex(state, rowId);\n    const row = state.rows[dataIndex];\n    const copiedCells: CominsCopiedCellRangeCell[] = [];\n\n    for (let columnIndex = bounds.columnStart; columnIndex <= bounds.columnEnd; columnIndex += 1) {\n      const column = bounds.visibleColumns[columnIndex];\n\n      if (row === undefined || rowId === undefined || !column || !canUseCellClipboard(state, row, rowId, column, \"copy\")) {\n        copiedCells.push(null);\n        continue;\n      }\n\n      const value = getCominsCellValue(state, row, column.id);\n      copiedCells.push({\n        columnId: column.id,\n        text: value == null ? \"\" : String(value),\n        value,\n      });\n    }\n\n    copiedRows.push(copiedCells);\n  }\n\n  return {\n    kind: \"cell-range\",\n    rows: copiedRows,\n    text: copiedRows.map((row) => row.map((cell) => cell?.text ?? \"\").join(\"\\t\")).join(\"\\n\"),\n  };\n}\n\nexport function pasteCominsCellRange<TData>(\n  state: CominsTableState<TData>,\n  target: CominsCellAddress,\n  copied: CominsCopiedCellRange | null,\n  rowIds: readonly CominsRowId[] = state.rowIds,\n) {\n  if (!copied) {\n    return state;\n  }\n\n  const visibleColumns = getCominsVisibleColumns(state);\n  const targetRowIndex = rowIds.indexOf(target.rowId);\n  const targetColumnIndex = visibleColumns.findIndex((column) => column.id === target.columnId);\n  const rows = [...state.rows];\n\n  if (targetRowIndex < 0 || targetColumnIndex < 0) {\n    return state;\n  }\n\n  let changed = false;\n\n  copied.rows.forEach((copiedRow, rowOffset) => {\n    const rowId = rowIds[targetRowIndex + rowOffset];\n    const rowIndex = rowId === undefined ? -1 : findRowIndex(state, rowId);\n    const row = rows[rowIndex];\n\n    if (row === undefined || rowId === undefined) {\n      return;\n    }\n\n    copiedRow.forEach((copiedCell, columnOffset) => {\n      const column = visibleColumns[targetColumnIndex + columnOffset];\n\n      if (!copiedCell || !column || !canUseCellClipboard(state, row, rowId, column, \"paste\")) {\n        return;\n      }\n\n      rows[rowIndex] = setNestedFieldValue(rows[rowIndex]!, column.field, copiedCell.value);\n      changed = true;\n    });\n  });\n\n  return changed ? withRows(state, rows) : state;\n}\n\nexport function pasteCominsText<TData>(\n  state: CominsTableState<TData>,\n  target: CominsCellAddress,\n  text: string,\n  rowIds: readonly CominsRowId[] = state.rowIds,\n) {\n  const matrix = parseCominsClipboardText(text);\n  const columns = getCominsVisibleColumns(state);\n  const firstRow = rowIds.indexOf(target.rowId), firstColumn = columns.findIndex(column => column.id === target.columnId);\n  if (firstRow < 0 || firstColumn < 0) return state;\n  return applyClipboardMatrix(state, rowIds, firstRow, firstColumn, matrix.length,\n    matrix.reduce((max, row) => Math.max(max, row.length), 0), (rowOffset, columnOffset, column, row, rowId, rowIndex) => {\n      const value = matrix[rowOffset]?.[columnOffset];\n      if (value === undefined) return null;\n      const params = createCellComponentParams(state, row, rowId, column, rowIndex);\n      return { value: column.cell?.parseClipboard ? column.cell.parseClipboard({ ...params, text: value }) : value };\n    });\n}\n\nfunction applyClipboardMatrix<TData>(\n  state: CominsTableState<TData>, rowIds: readonly CominsRowId[], rowStart: number, columnStart: number,\n  height: number, width: number,\n  read: (rowOffset: number, columnOffset: number, column: CominsTableRuntimeColumn<TData>, row: TData, rowId: CominsRowId, rowIndex: number) => { value: unknown } | null,\n) {\n  if (height * width > MAX_CLIPBOARD_CELLS) throw new Error(\"Clipboard exceeds 100000 cells.\");\n  const columns = getCominsVisibleColumns(state);\n  const indexes = new Map(state.rowIds.map((id, index) => [id, index]));\n  const rows = [...state.rows];\n  let changed = false;\n  for (let y = 0; y < height && rowStart + y < rowIds.length; y++) {\n    const rowId = rowIds[rowStart + y]!;\n    const index = indexes.get(rowId), row = index === undefined ? undefined : state.rows[index];\n    if (index === undefined || row === undefined) continue;\n    for (let x = 0; x < width && columnStart + x < columns.length; x++) {\n      const column = columns[columnStart + x]!;\n      if (!canUseCellClipboard(state, row, rowId, column, \"paste\", index)) continue;\n      const cell = read(y, x, column, row, rowId, index);\n      if (!cell || Object.is(getNestedFieldValue(rows[index], column.field), cell.value)) continue;\n      rows[index] = setNestedFieldValue(rows[index]!, column.field, cell.value);\n      changed = true;\n    }\n  }\n  // Parsing and guards finish before publishing any changes; a thrown parser is atomic.\n  return changed ? withRows(state, rows) : state;\n}\n\nexport function fillCominsCellRange<TData>(\n  state: CominsTableState<TData>,\n  { source, target }: CominsFillCellRangeOptions,\n  rowIds: readonly CominsRowId[] = state.rowIds,\n) {\n  const sourceRange = \"anchor\" in source ? source : { anchor: source, focus: source };\n  const from = getCellRangeBounds(state, sourceRange, rowIds), to = getCellRangeBounds(state, target, rowIds);\n  if (!from || !to) return state;\n  const height = from.rowEnd - from.rowStart + 1, width = from.columnEnd - from.columnStart + 1;\n  if (height * width > MAX_CLIPBOARD_CELLS) throw new Error(\"Clipboard exceeds 100000 cells.\");\n  const indexes = new Map(state.rowIds.map((id, index) => [id, index]));\n  const pattern = Array.from({ length: height }, (_, y) => {\n    const id = rowIds[from.rowStart + y]!, index = indexes.get(id), row = index === undefined ? undefined : state.rows[index];\n    return Array.from({ length: width }, (_, x) => {\n      const column = from.visibleColumns[from.columnStart + x]!;\n      return row === undefined || !canUseCellClipboard(state, row, id, column, \"copy\", index)\n        ? null : { value: getNestedFieldValue(row, column.field) };\n    });\n  });\n  const mod = (value: number, size: number) => ((value % size) + size) % size;\n  return applyClipboardMatrix(state, rowIds, to.rowStart, to.columnStart,\n    to.rowEnd - to.rowStart + 1, to.columnEnd - to.columnStart + 1,\n    (y, x, column, row, rowId, rowIndex) => {\n      const cell = pattern[mod(to.rowStart + y - from.rowStart, height)]![mod(to.columnStart + x - from.columnStart, width)]!;\n      if (cell && !Object.is(getNestedFieldValue(row, column.field), cell.value) && column.cell?.validateFill) {\n        const params = createCellComponentParams(state, row, rowId, column, rowIndex);\n        if (column.cell.validateFill({ ...params, value: cell.value }) === false) {\n          throw new Error(`Fill rejected for column \"${column.id}\".`);\n        }\n      }\n      return cell;\n    });\n}\n"],"mappings":"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"}

package/dist/core-compat-BO-JJudO.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"core-compat-BO-JJudO.js","names":["getCominsCellValue","columns.setCominsColumnWidth","columns.setCominsColumnHidden","columns.setCominsColumnGroupHidden","columns.setCominsColumnGroupWidth","columns.moveCominsColumn","columns.moveCominsColumnGroup","columns.serializeCominsColumnLayout","columns.applyCominsColumnLayout","selection.selectRow","selection.selectRows","selection.selectCell","selection.selectCellRange","selection.clearCominsCellRange","selection.clearCominsSelection","selection.isCominsRowSelected","selection.isCominsCellSelected","selection.getCominsSelectedCellRange","selection.isCominsCellInSelectedRange","table.queryCominsRows","table.replaceCominsRows","table.addCominsRows","table.updateCominsRows","table.deleteCominsRows","table.setCominsHeaderVisible","table.setCominsPagination","table.setCominsSortState","table.setCominsSortModel","table.clearCominsSortState","table.getCominsSortedRowIndexes","table.sortCominsRows","table.getCominsPageRows","table.getCominsVirtualRows","table.moveCominsRow","table.moveCominsRowToGroup","table.getCominsCellValue","columns.normalizeColumns","columns.normalizeColumnGroups","table.createCominsTableState","columns.getCominsVisibleColumns","columns.getCominsHeaderRows","clipboard.copyCominsRow","clipboard.pasteCominsRow","cells.copyCominsCell","cells.pasteCominsCell","clipboard.copyCominsCellRange","clipboard.pasteCominsCellRange","clipboard.pasteCominsText","clipboard.fillCominsCellRange","clearCominsSelection$1","getCominsHeaderRows$1","setCominsHeaderVisible$1","sortCominsRows$1","setCominsSortState$1","selectCell$1","normalizeColumns","moveCominsColumn$1","selectCellRange$1","setCominsColumnGroupWidth$1","serializeCominsColumnLayout$1","selectRow$1","isCominsCellInSelectedRange$1","isCominsCellSelected$1","updateCominsRows$1","isCominsRowSelected$1","selectRows$1","replaceCominsRows$1","setCominsSortModel$1","moveCominsColumnGroup$1","getCominsVisibleColumns$1","normalizeColumnGroups","setCominsColumnWidth$1","setCominsColumnHidden$1","getCominsSortedRowIndexes$1","pasteCominsRow$1","moveCominsRowToGroup$1","addCominsRows$1","clearCominsSortState$1","getCominsPageRows$1","getCominsCellValue$1","pasteCominsCellRange$1","getCominsSelectedCellRange$1","pasteCominsCell$1","deleteCominsRows$1","copyCominsRow$1","pasteCominsText$1","createCominsTableState$1","setCominsColumnGroupHidden$1","fillCominsCellRange$1","copyCominsCell$1","copyCominsCellRange$1","getCominsVirtualRows$1","setCominsPagination$1","queryCominsRows$1","moveCominsRow$1","applyCominsColumnLayout$1","createCellComponentParams","state","rowId","column","current","row","rowIndex","resolveGuard","guard","params","resolveCellProps","props","createReactEditPolicy","evaluations","evaluate","cached","payload","definition","result","projectReactColumn","sort","filter","left","right","leftRow","rightRow","projectReactGroup","group","projectReactState","columnSources","groupSources","source","projected","original","restoreReactState","next","bridge","setCominsColumnWidth","columnId","width","setCominsColumnHidden","hidden","setCominsColumnGroupHidden","groupId","setCominsColumnGroupWidth","moveCominsColumn","targetIndex","moveCominsColumnGroup","serializeCominsColumnLayout","applyCominsColumnLayout","layout","selectRow","options","selectRows","rowIds","selectCell","cell","selectCellRange","range","clearCominsCellRange","clearCominsCellRange$1","clearCominsSelection","isCominsRowSelected","isCominsCellSelected","getCominsSelectedCellRange","isCominsCellInSelectedRange","queryCominsRows","predicate","replaceCominsRows","rows","addCominsRows","updateCominsRows","updates","deleteCominsRows","setCominsHeaderVisible","showHeader","setCominsPagination","pagination","setCominsSortState","setCominsSortModel","sortModel","clearCominsSortState","getCominsSortedRowIndexes","index","sourceIndexes","sortCominsRows","getCominsPageRows","getCominsVirtualRows","moveCominsRow","moveCominsRowToGroup","getCominsCellValue","createCominsTableState","runtimeColumns","input","runtimeGroups","getCominsVisibleColumns","getCominsHeaderRows","setCominsTableTheme","theme","formatCominsCellValue","value","isCominsCellDisabled","getCominsCellClassName","className","getCominsCellStyle","style","copyCominsRow","pasteCominsRow","copied","copyCominsCell","pasteCominsCell","copyCominsCellRange","pasteCominsCellRange","target","pasteCominsText","text","fillCominsCellRange"],"sources":["../src/react/edit-policy.ts","../src/react/model.ts","../src/react/core-compat.ts"],"sourcesContent":["import type { CoreCellDataConfig, CominsCellComponentPayload as CorePayload } from \"../core/model\";\nimport type {\n  CominsTableState, CominsTableRuntimeColumn, CominsCellComponentPayload, CominsClipboardGuard,\n} from \"../react-types\";\nimport type { CominsRowId } from \"../model\";\nimport { getCominsCellValue } from \"../core/state/table\";\n\nexport function createCellComponentParams<TData>(\n  state: CominsTableState<TData>,\n  row: TData,\n  rowId: CominsRowId,\n  column: CominsTableRuntimeColumn<TData>,\n  rowIndex = state.rowIds.indexOf(rowId),\n): CominsCellComponentPayload<TData> {\n  return {\n    column: {\n      definition: column,\n      field: column.field,\n      id: column.id,\n      index: state.columns.findIndex((current) => current.id === column.id),\n      label: column.label,\n    },\n    row: {\n      data: row,\n      dataIndex: rowIndex,\n      disabled: false,\n      id: rowId,\n      index: rowIndex,\n      selected: state.selection.rowIds.includes(rowId),\n    },\n    selection: {\n      selectedRowCount: state.selection.rowIds.length,\n    },\n    value: getCominsCellValue(state, row, column.id),\n  };\n}\n\nexport function resolveGuard<TData>(\n  guard: CominsClipboardGuard<TData> | undefined,\n  params: CominsCellComponentPayload<TData>,\n) {\n  if (guard === undefined) {\n    return true;\n  }\n\n  return typeof guard === \"boolean\" ? guard : guard(params);\n}\n\nexport function resolveCellProps<TData>(\n  state: CominsTableState<TData>,\n  row: TData,\n  rowId: CominsRowId,\n  column: CominsTableRuntimeColumn<TData>,\n) {\n  const params = createCellComponentParams(state, row, rowId, column);\n  const props = column.cell?.props;\n\n  return typeof props === \"function\" ? props(params) : props;\n}\n\n/** Interpret React props once per guard evaluation, retaining the original payload and receiver. */\nexport function createReactEditPolicy<TData>(\n  state: CominsTableState<TData>,\n  column: CominsTableRuntimeColumn<TData>,\n): CoreCellDataConfig<TData> {\n  const evaluations = new WeakMap<CorePayload<TData>, {\n    params: CominsCellComponentPayload<TData>;\n    props: ReturnType<typeof resolveCellProps<TData>>;\n  }>();\n  const evaluate = (payload: CorePayload<TData>) => {\n    const cached = evaluations.get(payload);\n    if (cached) return cached;\n    const params = createCellComponentParams(state, payload.row.data, payload.row.id, column, payload.row.dataIndex);\n    const definition = column.cell?.props;\n    const result = { params, props: typeof definition === \"function\" ? definition(params) : definition };\n    evaluations.set(payload, result);\n    return result;\n  };\n  return {\n    disabled: payload => {\n      const { params, props } = evaluate(payload);\n      return props?.disabled !== undefined && resolveGuard(props.disabled, params) === true;\n    },\n    copyable: payload => {\n      const { params, props } = evaluate(payload);\n      return resolveGuard(props?.copyable, params);\n    },\n    pasteable: payload => {\n      const { params, props } = evaluate(payload);\n      return resolveGuard(props?.pasteable, params);\n    },\n    parseClipboard: column.cell?.parseClipboard ? payload => column.cell!.parseClipboard!({\n      ...createCellComponentParams(state, payload.row.data, payload.row.id, column, payload.row.dataIndex),\n      text: payload.text,\n    }) : undefined,\n    validateFill: column.cell?.validateFill ? payload => column.cell!.validateFill!({\n      ...createCellComponentParams(state, payload.row.data, payload.row.id, column, payload.row.dataIndex),\n      value: payload.value,\n    }) : undefined,\n  };\n}\n","import type * as Core from \"../core/model\";\nimport type * as React from \"../react-types\";\nimport { createReactEditPolicy } from \"./edit-policy\";\n\n/** Only data options cross the boundary; state-dependent cell policies are attached by the bridge. */\nexport function projectReactColumn<TData>(column: React.CominsTableRuntimeColumn<TData>): Core.CominsTableRuntimeColumn<TData> {\n  const sort = column.sort;\n  const filter = column.filter;\n  return {\n    id: column.id, field: column.field,\n    label: typeof column.label === \"string\" ? column.label : column.id,\n    hidden: column.hidden, lockPosition: column.lockPosition,\n    minWidth: column.minWidth, maxWidth: column.maxWidth, width: column.width, pinned: column.pinned,\n    sort: typeof sort === \"function\" ? (left, right, leftRow, rightRow) => sort.call(column, left, right, leftRow, rightRow) : sort,\n    filter: filter && { kind: filter.kind, caseSensitive: filter.caseSensitive, getOptionLabel: filter.getOptionLabel, getValue: filter.getValue\n      ? params => filter.getValue!({ ...params, column }) : undefined },\n  };\n}\n\nexport function projectReactGroup(group: React.CominsTableRuntimeColumnGroup): Core.CominsTableRuntimeColumnGroup {\n  return { id: group.id, children: group.children, hidden: group.hidden, lockPosition: group.lockPosition,\n    pinned: group.pinned, label: typeof group.label === \"string\" ? group.label : group.id };\n}\n\nexport type ReactStateBridge<TData> = {\n  source: React.CominsTableState<TData>;\n  core: Core.CominsTableState<TData>;\n  restoreColumn: (column: Core.CominsTableRuntimeColumn<TData>) => React.CominsTableRuntimeColumn<TData>;\n  restoreGroup: (group: Core.CominsTableRuntimeColumnGroup) => React.CominsTableRuntimeColumnGroup;\n};\n\nexport function projectReactState<TData>(source: React.CominsTableState<TData>): ReactStateBridge<TData> {\n  const columnSources = new Map<Core.CominsTableRuntimeColumn<TData>, React.CominsTableRuntimeColumn<TData>>();\n  const groupSources = new Map<Core.CominsTableRuntimeColumnGroup, React.CominsTableRuntimeColumnGroup>();\n  const columns = source.columns.map(column => {\n    const projected = projectReactColumn(column);\n    if (column.cell) projected.cell = createReactEditPolicy(source, column);\n    columnSources.set(projected, column);\n    return projected;\n  });\n  const columnGroups = source.columnGroups.map(group => {\n    const projected = projectReactGroup(group);\n    groupSources.set(projected, group);\n    return projected;\n  });\n  return {\n    source,\n    core: {\n      columns, columnGroups, columnOrder: source.columnOrder,\n      columnState: source.columnState, columnGroupState: source.columnGroupState,\n      rows: source.rows, rowIds: source.rowIds, getRowId: source.getRowId,\n      pagination: source.pagination, selection: source.selection, showHeader: source.showHeader,\n      sort: source.sort, sortModel: source.sortModel,\n    },\n    restoreColumn(column) {\n      const original = columnSources.get(column);\n      if (!original) throw new Error(\"Cannot restore a column from a different React state bridge.\");\n      return original;\n    },\n    restoreGroup(group) {\n      const original = groupSources.get(group);\n      if (!original) throw new Error(\"Cannot restore a group from a different React state bridge.\");\n      return original;\n    },\n  };\n}\n\nexport function restoreReactState<TData>(bridge: ReactStateBridge<TData>, next: Core.CominsTableState<TData>): React.CominsTableState<TData> {\n  if (next === bridge.core) return bridge.source;\n  return {\n    ...bridge.source, ...next,\n    columns: next.columns === bridge.core.columns ? bridge.source.columns : next.columns.map(bridge.restoreColumn),\n    columnGroups: next.columnGroups === bridge.core.columnGroups ? bridge.source.columnGroups : next.columnGroups.map(bridge.restoreGroup),\n  };\n}\n","import type { CominsTableTheme, CominsTableRuntimeColumn } from \"../react-types\";\nexport type { CominsColumnPinned } from \"../column-pinning\";\n\nexport type {\n  CominsRowId,\n  CominsTableDensity,\n  CominsSortDirection,\n  CominsSortState,\n  CominsSortModel,\n  CominsComponentPrimitiveValue,\n  CominsComponentAlign,\n  CominsComponentDirection,\n  CominsComponentPlacement,\n  CominsComponentRowPayload,\n  CominsColumnRuntimeState,\n  CominsColumnGroupRuntimeState,\n  CominsColumnLayout,\n  CominsPaginationState,\n  CominsSelectionState,\n  CominsRowUpdate,\n  CominsVirtualRowsOptions,\n  CominsVirtualRows,\n  CominsCopiedRow,\n  CominsCopiedCell,\n  CominsCopiedCellRangeCell,\n  CominsCopiedCellRange,\n  CominsExportFormat,\n  CominsExportValueSource,\n  CominsExportColumn,\n  CominsExportRowsOptions,\n  CominsCellAddress,\n  CominsCellRange,\n  CominsPasteRowOptions,\n  CominsRowSelectionOptions,\n  CominsCellSelectionOptions,\n  CominsFillCellRangeOptions,\n} from \"../model\";\n\nexport type {\n  CominsTableTheme,\n  CominsCellFormatParams,\n  CominsColumnValueResolver,\n  CominsTableComponentOption,\n  CominsVirtualListItem,\n  CominsTableMenuItem,\n  CominsComponentColumnPayload,\n  CominsCellComponentPayload,\n  CominsHeaderComponentPayload,\n  CominsClipboardGuard,\n  CominsColumnProps,\n  CominsTableComponentProps,\n  CominsTableOptions,\n  CominsTableMenuItems,\n  CominsVirtualListItems,\n  CominsButtonComponentConfig,\n  CominsInputCommitEvent,\n  CominsInputComponentConfig,\n  CominsCheckboxComponentConfig,\n  CominsRadioComponentConfig,\n  CominsSelectComponentConfig,\n  CominsToggleComponentConfig,\n  CominsProgressComponentConfig,\n  CominsMenuComponentConfig,\n  CominsVirtualListSearchFilterPayload,\n  CominsVirtualListComponentConfig,\n  CominsHeaderComponentConfig,\n  CominsCellComponentConfig,\n  CominsHeaderComponent,\n  CominsCellComponent,\n  CominsTableCellConfig,\n  CominsTableHeaderConfig,\n  CominsTableColumn,\n  CominsTableColumnGroup,\n  CominsTableRuntimeColumn,\n  CominsTableRuntimeColumnGroup,\n  CominsEventColumn,\n  CominsTableState,\n  CominsTableStateInput,\n  CominsHeaderColumnCell,\n  CominsHeaderGroupCell,\n  CominsHeaderCell,\n} from \"../react-types\";\nexport { parseCominsClipboardText } from \"../clipboard-text\";\nimport type {\n  CominsCopiedRow, CominsCopiedCell, CominsCopiedCellRange, CominsPasteRowOptions, CominsFillCellRangeOptions,\n} from \"../model\";\nimport * as cells from \"../core/editing/cells\";\nimport * as clipboard from \"../core/editing/clipboard\";\nimport { createCellComponentParams, resolveCellProps, resolveGuard } from \"./edit-policy\";\nimport type {\n  CominsTableState,\n  CominsTableStateInput,\n  CominsHeaderCell,\n} from \"../react-types\";\nimport type {\n  CominsRowId,\n  CominsSortState,\n  CominsSortModel,\n  CominsColumnLayout,\n  CominsPaginationState,\n  CominsRowUpdate,\n  CominsVirtualRowsOptions,\n  CominsVirtualRows,\n  CominsCellAddress,\n  CominsCellRange,\n  CominsRowSelectionOptions,\n  CominsCellSelectionOptions,\n} from \"../core/model\";\nimport * as table from \"../core/state/table\";\nimport * as columns from \"../core/layout/columns\";\nimport * as selection from \"../core/selection/state\";\nimport {\n  projectReactState,\n  restoreReactState,\n  projectReactColumn,\n  projectReactGroup,\n} from \"./model\";\nexport type { CominsRowGroupMoveOptions } from \"../core/state/table\";\nimport type {\n  CominsRowGroupMoveOptions,\n} from \"../core/state/table\";\n\nexport function setCominsColumnWidth<TData>(\n  state: CominsTableState<TData>,\n  columnId: string,\n  width: number,\n) {\n  const bridge = projectReactState(state);\n  const next = columns.setCominsColumnWidth(bridge.core, columnId, width);\n  return restoreReactState(bridge, next);\n}\n\nexport function setCominsColumnHidden<TData>(\n  state: CominsTableState<TData>,\n  columnId: string,\n  hidden: boolean,\n) {\n  const bridge = projectReactState(state);\n  const next = columns.setCominsColumnHidden(bridge.core, columnId, hidden);\n  return restoreReactState(bridge, next);\n}\n\nexport function setCominsColumnGroupHidden<TData>(\n  state: CominsTableState<TData>,\n  groupId: string,\n  hidden: boolean,\n) {\n  const bridge = projectReactState(state);\n  const next = columns.setCominsColumnGroupHidden(bridge.core, groupId, hidden);\n  return restoreReactState(bridge, next);\n}\n\nexport function setCominsColumnGroupWidth<TData>(\n  state: CominsTableState<TData>,\n  groupId: string,\n  width: number,\n) {\n  const bridge = projectReactState(state);\n  const next = columns.setCominsColumnGroupWidth(bridge.core, groupId, width);\n  return restoreReactState(bridge, next);\n}\n\nexport function moveCominsColumn<TData>(\n  state: CominsTableState<TData>,\n  columnId: string,\n  targetIndex: number,\n) {\n  const bridge = projectReactState(state);\n  const next = columns.moveCominsColumn(bridge.core, columnId, targetIndex);\n  return restoreReactState(bridge, next);\n}\n\nexport function moveCominsColumnGroup<TData>(\n  state: CominsTableState<TData>,\n  groupId: string,\n  targetIndex: number,\n) {\n  const bridge = projectReactState(state);\n  const next = columns.moveCominsColumnGroup(bridge.core, groupId, targetIndex);\n  return restoreReactState(bridge, next);\n}\n\nexport function serializeCominsColumnLayout<TData>(state: CominsTableState<TData>): CominsColumnLayout {\n  const bridge = projectReactState(state);\n  const next = columns.serializeCominsColumnLayout(bridge.core);\n  return next;\n}\n\nexport function applyCominsColumnLayout<TData>(state: CominsTableState<TData>, layout: CominsColumnLayout) {\n  const bridge = projectReactState(state);\n  const next = columns.applyCominsColumnLayout(bridge.core, layout);\n  return restoreReactState(bridge, next);\n}\n\nexport function selectRow<TData>(\n  state: CominsTableState<TData>,\n  rowId: CominsRowId,\n  options: CominsRowSelectionOptions = {},\n) {\n  const bridge = projectReactState(state);\n  const next = selection.selectRow(bridge.core, rowId, options);\n  return restoreReactState(bridge, next);\n}\n\nexport function selectRows<TData>(state: CominsTableState<TData>, rowIds: readonly CominsRowId[]) {\n  const bridge = projectReactState(state);\n  const next = selection.selectRows(bridge.core, rowIds);\n  return restoreReactState(bridge, next);\n}\n\nexport function selectCell<TData>(\n  state: CominsTableState<TData>,\n  cell: CominsCellAddress,\n  options: CominsCellSelectionOptions = {},\n) {\n  const bridge = projectReactState(state);\n  const next = selection.selectCell(bridge.core, cell, options);\n  return { ...restoreReactState(bridge, next), selection: next.selection };\n}\n\nexport function selectCellRange<TData>(state: CominsTableState<TData>, range: CominsCellRange) {\n  const bridge = projectReactState(state);\n  const next = selection.selectCellRange(bridge.core, range);\n  return { ...restoreReactState(bridge, next), selection: next.selection };\n}\n\nexport function clearCominsCellRange<TData>(state: CominsTableState<TData>) {\n  const bridge = projectReactState(state);\n  const next = selection.clearCominsCellRange(bridge.core);\n  return { ...restoreReactState(bridge, next), selection: next.selection };\n}\n\nexport function clearCominsSelection<TData>(state: CominsTableState<TData>) {\n  const bridge = projectReactState(state);\n  const next = selection.clearCominsSelection(bridge.core);\n  return restoreReactState(bridge, next);\n}\n\nexport function isCominsRowSelected<TData>(state: CominsTableState<TData>, rowId: CominsRowId) {\n  return selection.isCominsRowSelected(state, rowId);\n}\n\nexport function isCominsCellSelected<TData>(state: CominsTableState<TData>, cell: CominsCellAddress) {\n  return selection.isCominsCellSelected(state, cell);\n}\n\nexport function getCominsSelectedCellRange<TData>(\n  state: CominsTableState<TData>,\n  range: CominsCellRange | null = state.selection.range,\n  rowIds: readonly CominsRowId[] = state.rowIds,\n) {\n  const bridge = projectReactState(state);\n  const next = selection.getCominsSelectedCellRange(bridge.core, range, rowIds);\n  return next;\n}\n\nexport function isCominsCellInSelectedRange<TData>(\n  state: CominsTableState<TData>,\n  cell: CominsCellAddress,\n  rowIds: readonly CominsRowId[] = state.rowIds,\n) {\n  const bridge = projectReactState(state);\n  const next = selection.isCominsCellInSelectedRange(bridge.core, cell, rowIds);\n  return next;\n}\n\nexport function queryCominsRows<TData>(\n  state: CominsTableState<TData>,\n  predicate?: (row: TData, index: number) => boolean,\n) {\n  return table.queryCominsRows(state, predicate);\n}\n\nexport function replaceCominsRows<TData>(state: CominsTableState<TData>, rows: readonly TData[]) {\n  const bridge = projectReactState(state);\n  const next = table.replaceCominsRows(bridge.core, rows);\n  return restoreReactState(bridge, next);\n}\n\nexport function addCominsRows<TData>(state: CominsTableState<TData>, rows: readonly TData[]) {\n  const bridge = projectReactState(state);\n  const next = table.addCominsRows(bridge.core, rows);\n  return restoreReactState(bridge, next);\n}\n\nexport function updateCominsRows<TData>(\n  state: CominsTableState<TData>,\n  updates: ReadonlyArray<CominsRowUpdate<TData>>,\n) {\n  const bridge = projectReactState(state);\n  const next = table.updateCominsRows(bridge.core, updates);\n  return restoreReactState(bridge, next);\n}\n\nexport function deleteCominsRows<TData>(state: CominsTableState<TData>, rowIds: readonly CominsRowId[]) {\n  const bridge = projectReactState(state);\n  const next = table.deleteCominsRows(bridge.core, rowIds);\n  return restoreReactState(bridge, next);\n}\n\nexport function setCominsHeaderVisible<TData>(state: CominsTableState<TData>, showHeader: boolean) {\n  const bridge = projectReactState(state);\n  const next = table.setCominsHeaderVisible(bridge.core, showHeader);\n  return restoreReactState(bridge, next);\n}\n\nexport function setCominsPagination<TData>(\n  state: CominsTableState<TData>,\n  pagination: Partial<CominsPaginationState>,\n) {\n  const bridge = projectReactState(state);\n  const next = table.setCominsPagination(bridge.core, pagination);\n  return restoreReactState(bridge, next);\n}\n\nexport function setCominsSortState<TData>(\n  state: CominsTableState<TData>,\n  sort: CominsSortState | null,\n) {\n  const bridge = projectReactState(state);\n  const next = table.setCominsSortState(bridge.core, sort);\n  return restoreReactState(bridge, next);\n}\n\nexport function setCominsSortModel<TData>(\n  state: CominsTableState<TData>,\n  sortModel: CominsSortModel,\n) {\n  const bridge = projectReactState(state);\n  const next = table.setCominsSortModel(bridge.core, sortModel);\n  return restoreReactState(bridge, next);\n}\n\nexport function clearCominsSortState<TData>(state: CominsTableState<TData>) {\n  const bridge = projectReactState(state);\n  const next = table.clearCominsSortState(bridge.core);\n  return restoreReactState(bridge, next);\n}\n\nexport function getCominsSortedRowIndexes<TData>(\n  state: CominsTableState<TData>,\n  sourceIndexes: readonly number[] = state.rows.map((_row, index) => index),\n) {\n  const bridge = projectReactState(state);\n  const next = table.getCominsSortedRowIndexes(bridge.core, sourceIndexes);\n  return next;\n}\n\nexport function sortCominsRows<TData>(\n  state: CominsTableState<TData>,\n  sort: CominsSortState | null,\n) {\n  const bridge = projectReactState(state);\n  const next = table.sortCominsRows(bridge.core, sort);\n  return restoreReactState(bridge, next);\n}\n\nexport function getCominsPageRows<TData>(\n  state: CominsTableState<TData>,\n  pagination: Partial<CominsPaginationState> = {},\n) {\n  const bridge = projectReactState(state);\n  const next = table.getCominsPageRows(bridge.core, pagination);\n  return next;\n}\n\nexport function getCominsVirtualRows<TData>(\n  state: CominsTableState<TData>,\n  { overscan = 2, rowHeight, scrollTop, viewportHeight }: CominsVirtualRowsOptions,\n): CominsVirtualRows<TData> {\n  const bridge = projectReactState(state);\n  const next = table.getCominsVirtualRows(bridge.core, { overscan, rowHeight, scrollTop, viewportHeight });\n  return next;\n}\n\nexport function moveCominsRow<TData>(\n  state: CominsTableState<TData>,\n  rowId: CominsRowId,\n  targetIndex: number,\n) {\n  const bridge = projectReactState(state);\n  const next = table.moveCominsRow(bridge.core, rowId, targetIndex);\n  return restoreReactState(bridge, next);\n}\n\nexport function moveCominsRowToGroup<TData>(\n  state: CominsTableState<TData>,\n  options: CominsRowGroupMoveOptions<TData>,\n) {\n  const bridge = projectReactState(state);\n  const next = table.moveCominsRowToGroup(bridge.core, options);\n  return restoreReactState(bridge, next);\n}\n\nexport function getCominsCellValue<TData>(\n  state: CominsTableState<TData>,\n  row: TData,\n  columnId: string,\n) {\n  return table.getCominsCellValue(state, row, columnId);\n}\n\nexport function createCominsTableState<TData>(input: CominsTableStateInput<TData>): CominsTableState<TData> {\n  const runtimeColumns = columns.normalizeColumns(input.columns);\n  const runtimeGroups = columns.normalizeColumnGroups(runtimeColumns, input.columnGroups);\n  const state = table.createCominsTableState({ ...input, columns: runtimeColumns.map(projectReactColumn), columnGroups: runtimeGroups.map(projectReactGroup) });\n  return { ...state, columns: runtimeColumns, columnGroups: runtimeGroups, theme: input.theme ?? {} };\n}\n\nexport function getCominsVisibleColumns<TData>(state: CominsTableState<TData>) {\n  const bridge = projectReactState(state);\n  return columns.getCominsVisibleColumns(bridge.core).map(bridge.restoreColumn);\n}\n\nexport function getCominsHeaderRows<TData>(state: CominsTableState<TData>): Array<Array<CominsHeaderCell<TData>>> {\n  const bridge = projectReactState(state);\n  return columns.getCominsHeaderRows(bridge.core).map(row => row.map(cell => cell.kind === \"column\"\n    ? { ...cell, column: bridge.restoreColumn(cell.column) }\n    : { ...cell, group: bridge.restoreGroup(cell.group) }));\n}\n\nexport function setCominsTableTheme<TData>(state: CominsTableState<TData>, theme: CominsTableTheme) {\n  return {\n    ...state,\n    theme: { ...state.theme, ...theme },\n  };\n}\n\nexport function formatCominsCellValue<TData>(\n  state: CominsTableState<TData>,\n  row: TData,\n  rowId: CominsRowId,\n  column: CominsTableRuntimeColumn<TData>,\n) {\n  const value = getCominsCellValue(state, row, column.id);\n\n  if (column.cell?.format) {\n    return column.cell.format(createCellComponentParams(state, row, rowId, column));\n  }\n\n  return value == null ? \"\" : String(value);\n}\n\nexport function isCominsCellDisabled<TData>(\n  state: CominsTableState<TData>,\n  row: TData,\n  rowId: CominsRowId,\n  column: CominsTableRuntimeColumn<TData>,\n) {\n  const props = resolveCellProps(state, row, rowId, column);\n\n  return props?.disabled !== undefined && resolveGuard(props.disabled, createCellComponentParams(state, row, rowId, column)) === true;\n}\n\nexport function getCominsCellClassName<TData>(\n  state: CominsTableState<TData>,\n  row: TData,\n  rowId: CominsRowId,\n  column: CominsTableRuntimeColumn<TData>,\n) {\n  const params = createCellComponentParams(state, row, rowId, column);\n  const className = resolveCellProps(state, row, rowId, column)?.className;\n\n  return typeof className === \"function\" ? className(params) : className;\n}\n\nexport function getCominsCellStyle<TData>(\n  state: CominsTableState<TData>,\n  row: TData,\n  rowId: CominsRowId,\n  column: CominsTableRuntimeColumn<TData>,\n) {\n  const params = createCellComponentParams(state, row, rowId, column);\n  const style = resolveCellProps(state, row, rowId, column)?.style;\n\n  return typeof style === \"function\" ? style(params) : style;\n}\n\nexport function copyCominsRow<TData>(state: CominsTableState<TData>, rowId: CominsRowId): CominsCopiedRow<TData> {\n  const bridge = projectReactState(state);\n  return clipboard.copyCominsRow(bridge.core, rowId);\n}\n\nexport function pasteCominsRow<TData>(\n  state: CominsTableState<TData>,\n  copied: CominsCopiedRow<TData>,\n  options: CominsPasteRowOptions<TData>,\n) {\n  const bridge = projectReactState(state);\n  const next = clipboard.pasteCominsRow(bridge.core, copied, options);\n  return restoreReactState(bridge, next);\n}\n\nexport function copyCominsCell<TData>(\n  state: CominsTableState<TData>,\n  { columnId, rowId }: CominsCellAddress,\n): CominsCopiedCell | null {\n  const bridge = projectReactState(state);\n  return cells.copyCominsCell(bridge.core, { columnId, rowId });\n}\n\nexport function pasteCominsCell<TData>(\n  state: CominsTableState<TData>,\n  { columnId, rowId }: CominsCellAddress,\n  copied: CominsCopiedCell | null,\n) {\n  const bridge = projectReactState(state);\n  const next = cells.pasteCominsCell(bridge.core, { columnId, rowId }, copied);\n  return restoreReactState(bridge, next);\n}\n\nexport function copyCominsCellRange<TData>(\n  state: CominsTableState<TData>,\n  range: CominsCellRange | null = state.selection.range,\n  rowIds: readonly CominsRowId[] = state.rowIds,\n): CominsCopiedCellRange | null {\n  const bridge = projectReactState(state);\n  return clipboard.copyCominsCellRange(bridge.core, range, rowIds);\n}\n\nexport function pasteCominsCellRange<TData>(\n  state: CominsTableState<TData>,\n  target: CominsCellAddress,\n  copied: CominsCopiedCellRange | null,\n  rowIds: readonly CominsRowId[] = state.rowIds,\n) {\n  const bridge = projectReactState(state);\n  const next = clipboard.pasteCominsCellRange(bridge.core, target, copied, rowIds);\n  return restoreReactState(bridge, next);\n}\n\nexport function pasteCominsText<TData>(\n  state: CominsTableState<TData>,\n  target: CominsCellAddress,\n  text: string,\n  rowIds: readonly CominsRowId[] = state.rowIds,\n) {\n  const bridge = projectReactState(state);\n  const next = clipboard.pasteCominsText(bridge.core, target, text, rowIds);\n  return restoreReactState(bridge, next);\n}\n\nexport function fillCominsCellRange<TData>(\n  state: CominsTableState<TData>,\n  { source, target }: CominsFillCellRangeOptions,\n  rowIds: readonly CominsRowId[] = state.rowIds,\n) {\n  const bridge = projectReactState(state);\n  const next = clipboard.fillCominsCellRange(bridge.core, { source, target }, rowIds);\n  return restoreReactState(bridge, next);\n}\n"],"mappings":"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"}