@syidax/advanced 0.0.0-stage → 1.0.1

package/dist/collection/components/grid/core/pro-gate/grid-freeze-work.js

@@ -0,0 +1 @@
+export class GridHeldDeclaration{feature;same;applied=null;heldBack=false;constructor(feature,same){this.feature=feature;this.same=same}get held(){return this.heldBack}get current(){return this.applied}resolve(declared,license){if(declared===null){this.applied=null;this.heldBack=false;return null}const applied=this.applied;if(applied!==null&&this.same(declared,applied)){this.heldBack=false;return declared}if(!license.entitled(this.feature)){this.heldBack=true;return applied}this.applied=declared;this.heldBack=false;return declared}clear(){this.applied=null;this.heldBack=false}resume(license){if(!this.heldBack||!license.entitled(this.feature))return false;this.heldBack=false;return true}}export class GridHeldInits{held=new Map;hold(key,feature){this.held.set(key,feature)}drop(key){this.held.delete(key)}has(key){return this.held.has(key)}release(license){const released=[];for(const[key,feature]of[...this.held]){if(!license.entitled(feature))continue;this.held.delete(key);released.push(key)}return released}}export const GRID_COLLAB_FEATURE="grid.collaboration";export class GridCollabFreeze{stoppedByLicense=false;get stopped(){return this.stoppedByLicense}holdJoin(){this.stoppedByLicense=true}onLicenseChange(license,stream){if(!stream.running()||!license.lost(GRID_COLLAB_FEATURE))return false;stream.stop();this.stoppedByLicense=true;return true}resume(license,stream){if(!this.stoppedByLicense||!license.entitled(GRID_COLLAB_FEATURE))return false;this.stoppedByLicense=false;if(!stream.roomDeclared()||stream.running())return false;stream.rejoin();return true}reset(){this.stoppedByLicense=false}}

package/dist/collection/components/grid/core/pro-gate/grid-pro-gate.js

@@ -0,0 +1,2 @@
+import{createGridLicense}from"../license/grid-license.js";import{GridFeatureError,gridFeatureRefusal,gridModuleFailure,runGridFeature}from"../license/grid-feature.js";import{runGridMethod}from"../license/grid-method-route.js";const refusing=state=>state!=="valid"&&state!=="pending";const SETTLE_ROUNDS=4;const FROZEN_ATTR="data-license-frozen";function refusalMessage(tag,refusal){const subject=`<${tag}> ${refusal.member}: "${refusal.feature}"`;if(refusal.action==="missing"){return`${subject} is licensed, but its module "${refusal.chunkId??"unknown"}" is not in this build (the Pro package carries it); the grid ignores it and keeps its Free behaviour.`}const cause=refusal.state==="load-failed"?"is unavailable because the grid license runtime could not load":`needs a valid grid Pro license (license state: ${refusal.state})`;const outcome=refusal.action==="inert"?"the grid ignores it and keeps its Free behaviour":"new work for it is refused; what is on screen is kept";return`${subject} ${cause}; ${outcome}.`}export class GridProGate{host;hooks;options;binding=null;display=new Map;noted=new Map;liveOnly=new Set;flushQueued=false;deferred=false;constructor(host,hooks,options){this.host=host;this.hooks=hooks;this.options=options}license(){if(this.binding===null){this.binding=createGridLicense(this.host,()=>this.onLicenseChange(),this.options)}return this.binding}displayRevision(){return this.binding===null?0:this.binding.displayRevision()}displayState(feature){let state=this.display.get(feature);if(state===void 0){state=this.license().displayState(feature);this.display.set(feature,state)}return state}allowed(feature,member){const state=this.displayState(feature);if(state==="valid")return true;if(refusing(state))this.note({feature,state,action:"inert",member});return false}workAllowed(feature,member){const state=this.license().liveState(feature);if(state==="valid")return true;if(refusing(state))this.note({feature,state,action:"refused",member});return false}newWorkAllowed(feature,member){return this.allowed(feature,member)&&this.workAllowed(feature,member)}moduleAvailable(feature,member,chunkId,available){if(available)return true;this.note({feature,state:"valid",action:"missing",member,chunkId});return false}lost(feature){return refusing(this.license().liveState(feature))}async admitAny(features,member){if(features.length===0)return;const license=this.license();const entitled=()=>features.some(feature=>license.liveState(feature)==="valid");if(entitled())return;await this.settle(features);if(entitled())return;await this.admit(features[0],member)}liveDeclaration(feature,member){this.liveOnly.add(feature);const state=this.license().liveState(feature);if(refusing(state))this.note({feature,state,action:"inert",member});return state}admitChunk(chunkId,features){if(features.length===0)return void 0;const license=this.license();const entitled=()=>features.some(feature=>license.liveState(feature)==="valid");if(entitled())return void 0;return this.settle(features).then(()=>{if(entitled())return;const feature=features[0];const state=license.liveState(feature);const disposed=license.disposed();const error=new GridFeatureError({code:disposed?"disposed":state==="load-failed"?"load-failed":"license-required",feature,state,tag:license.tag,chunkId,reason:state==="load-failed"?"license runtime unavailable":void 0});if(!disposed&&error.code==="license-required"){error.message=`<${license.tag}> "${feature}" needs a valid grid Pro license (license state: ${state}); its module "${chunkId}" is not loaded.`}if(!disposed&&license.claimRefusal(feature,state,`chunk:${chunkId}`)){license.refused(error);this.hooks.changed(false)}throw error})}method(name,isLoaded,steps){return this.afterRefusal(runGridMethod(this.license(),name,isLoaded,steps))}moduleFailure(error,feature,method){const mapped=gridModuleFailure(this.license(),error,feature,method);if(mapped!==error&&this.binding!==null&&!this.binding.disposed())this.hooks.changed(false);return mapped}admit(feature,member){return this.afterRefusal(runGridFeature(this.license(),feature,{method:member,exec:()=>void 0}))}awaiting(features){if(features.length===0)return false;const license=this.license();return features.some(feature=>license.liveState(feature)==="pending")}async settle(features){if(features.length===0)return;const license=this.license();for(let round=0;round<SETTLE_ROUNDS;round+=1){const waiting=features.some(feature=>{const state=license.liveState(feature);return state==="pending"||round===0&&state==="load-failed"});if(!waiting||license.disposed())return;await license.settled()}}refuseRequest(features,member){if(features.length===0)return[];const license=this.license();const refusals=[];for(const feature of new Set(features)){const error=gridFeatureRefusal(license,feature,member);if(error!==null)refusals.push(error)}if(refusals.length>0&&!license.disposed())this.hooks.changed(false);return refusals}frozen(feature){return this.license().frozen(feature)}entitled(feature){return this.displayState(feature)==="valid"&&this.license().liveState(feature)==="valid"}refusalError(feature,member){const state=this.displayState(feature);return new GridFeatureError({code:state==="load-failed"?"load-failed":state==="pending"?"license-pending":"license-required",feature,state,tag:this.license().tag,method:member,reason:state==="load-failed"?"license runtime unavailable":void 0})}afterRefusal(request){return request.catch(error=>{if(error instanceof GridFeatureError&&error.code!=="disposed"&&this.binding!==null&&!this.binding.disposed()){this.hooks.changed(false)}throw error})}attributes(){if(this.binding===null)return{};const attributes=this.binding.attributes();const frozen=attributes[FROZEN_ATTR];if(this.liveOnly.size===0||frozen===void 0)return attributes;const kept=frozen.split(" ").filter(feature=>!this.liveOnly.has(feature));return{...attributes,[FROZEN_ATTR]:kept.length>0?kept.join(" "):void 0}}afterRender(){if(this.deferred&&this.hooks.safePoint())this.commit()}rebind(){if(this.binding===null)return;if(this.binding.rebind())this.onLicenseChange()}detach(){this.noted.clear();this.binding?.detach()}flushRefusals(){this.flushQueued=false;const noted=[...this.noted.values()];this.noted.clear();const binding=this.binding;if(binding===null||binding.disposed())return;let reported=false;for(const refusal of noted){if(!binding.claimRefusal(refusal.feature,refusal.state,refusal.action))continue;const missing=refusal.action==="missing";const error=new GridFeatureError({code:missing?"module-missing":refusal.state==="load-failed"?"load-failed":"license-required",feature:refusal.feature,state:refusal.state,tag:binding.tag,method:refusal.member,chunkId:refusal.chunkId,reason:missing?`chunk "${refusal.chunkId??"unknown"}" is not in this build`:refusal.state==="load-failed"?"license runtime unavailable":void 0});error.message=refusalMessage(binding.tag,refusal);binding.refused(error);reported=true}if(reported)this.hooks.changed(false)}note(refusal){const key=`${refusal.feature}
+${refusal.action}`;if(this.noted.has(key))return;this.noted.set(key,refusal);if(this.flushQueued)return;this.flushQueued=true;void Promise.resolve().then(()=>this.flushRefusals())}onLicenseChange(){if(this.binding===null||this.binding.disposed())return;try{this.hooks.liveChanged?.()}catch(error){const report=globalThis.reportError;if(typeof report==="function")report(error)}this.hooks.changed(false);if(!this.hooks.safePoint()){this.deferred=true;return}this.commit()}commit(){this.deferred=false;const binding=this.binding;if(binding===null)return;const before=new Map(this.display);if(!binding.commit())return;this.display.clear();this.hooks.changed(true);for(const[feature,was]of before){if(was!=="valid"&&this.displayState(feature)==="valid")this.hooks.activated(feature)}}}

package/dist/collection/components/grid/core/pro-gate/grid-state-requirements.js

@@ -0,0 +1 @@
+function columnEntryIndexes(state){const out=new Map;const slice=state?.slices?.columns;const entries=Array.isArray(slice?.entries)?slice.entries:[];entries.forEach((entry,index)=>{if(entry!==null&&typeof entry==="object"&&typeof entry.colId==="string"&&!out.has(entry.colId)){out.set(entry.colId,index)}});return out}export function scanGridStateProRequirements(plan,state){const out=[];if(!plan.ok)return out;const applied=new Set(plan.appliedSlices);const add=(feature,path,detail)=>{out.push({feature,path,detail})};const columns=plan.columns;if(columns!==null&&applied.has("columns")){const indexes=columnEntryIndexes(state);for(const field of columns.rowGroupFields){const index=indexes.get(field);add("grid.row-grouping",index===void 0?"$/slices/columns/entries":`$/slices/columns/entries/${index}/rowGroupIndex`,`row grouping by "${field}"`)}if(columns.pivotMode===true)add("grid.pivot","$/slices/columns/pivotMode","pivot mode")}const filter=plan.filter;if(filter!==null&&applied.has("filter"))out.push(...scanFilterProRequirements(filter,"$/slices/filter"));const rows=plan.rows;if(rows!==null){if(applied.has("rowGrouping")&&rows.collapsedGroupRoutes.length>0){add("grid.row-grouping","$/slices/rowGrouping/collapsedGroupRoutes","collapsed row groups")}if(applied.has("pivot")&&rows.pivotCollapsedGroupRoutes.length>0){add("grid.pivot","$/slices/pivot/collapsedGroupRoutes","collapsed pivot groups")}if(applied.has("expansion")&&rows.collapsedTreeNodePaths.length>0){add("grid.tree-data","$/slices/expansion/collapsedTreeNodePaths","collapsed tree nodes")}if(applied.has("expansion")&&rows.expandedDetailRowIds.length>0){add("grid.master-detail","$/slices/expansion/expandedDetailRowIds","expanded detail rows")}if(applied.has("selection")&&rows.ranges.length>0){add("grid.range-selection","$/slices/selection/ranges","cell ranges")}}const ui=plan.ui;if(plan.find&&applied.has("find"))add("grid.find","$/slices/find","find query and options");if(ui!==null&&applied.has("sideBar")&&ui.immediate.sideBar.openPanelId!==null){add("grid.tool-panels","$/slices/sideBar/openPanelId",`open tool panel "${ui.immediate.sideBar.openPanelId}"`)}return out}export function scanFilterProRequirements(filter,root){const out=[];for(const[column,active]of Object.entries(filter.builtIn)){const entry=active;const path=`${root}/builtIn/${column}`;if(entry?.kind==="set"){out.push({feature:"grid.set-filter",path,detail:`set filter on "${column}"`})}else if(entry?.kind==="multi"){out.push({feature:"grid.multi-filter",path,detail:`multi filter on "${column}"`});const parts=Array.isArray(entry.spec?.parts)?entry.spec.parts:[];if(parts.some(part=>part?.kind==="set"))out.push({feature:"grid.set-filter",path,detail:`set filter part on "${column}"`})}}if(filter.conditionTree!==null){out.push({feature:"grid.advanced-filter",path:`${root}/conditionTree`,detail:"advanced filter condition tree"})}return out}export function gridStateRequirementFeatures(requirements){const out=[];for(const requirement of requirements){if(!out.includes(requirement.feature))out.push(requirement.feature)}return out}function licenseCause(refused){if(refused.code==="license-pending")return"license verification pending";if(refused.code==="load-failed")return"license runtime unavailable";if(refused.code==="disposed")return"the grid was disconnected";return`license state: ${refused.state}`}export function gridStateLicenseIssues(requirements,refused){const byFeature=new Map(refused.map(entry=>[entry.feature,entry]));const out=[];for(const requirement of requirements){const refusal=byFeature.get(requirement.feature);if(refusal===void 0)continue;out.push({code:"not-entitled",path:requirement.path,detail:`${requirement.detail} needs the Grid Pro feature "${requirement.feature}" (${licenseCause(refusal)})`})}return out}export const GRID_PRO_FILTER_FEATURES=new Set(["grid.set-filter","grid.multi-filter","grid.advanced-filter"]);export function gridProFilterRequirements(requirements){return requirements.filter(requirement=>GRID_PRO_FILTER_FEATURES.has(requirement.feature))}export function gridStateModuleIssues(requirements,cause,chunkId){const why=cause==="module-missing"?"not in this build":"the module failed to load";return requirements.map(requirement=>({code:"not-entitled",path:requirement.path,detail:`${requirement.detail} needs the Grid Pro module '${chunkId}' of "${requirement.feature}" (${cause}: ${why})`}))}export function refusedGridStatePlan(plan,licenseIssues){return{...plan,ok:false,issues:[...plan.issues,...licenseIssues],appliedSlices:[],columns:null,filter:null,rows:null,ui:null}}

package/dist/collection/components/grid/core/rbac/cell-access.js

@@ -0,0 +1 @@
+function reportPolicyError(onError,error){if(typeof onError!=="function")return;try{onError(error)}catch{}}function invalidPolicyReturn(value){const kind=value===null?"null":typeof value;return new TypeError(`Cell access policy must return the synchronous literal boolean true; received ${kind}.`)}export function resolveCellReadable(params,policy,onError){if(policy===null||policy===void 0)return true;if(typeof policy!=="function"){reportPolicyError(onError,new TypeError("Cell access policy must be a function, null, or undefined."));return false}let result;try{result=policy(params)}catch(err){reportPolicyError(onError,err);return false}if(result===true)return true;if(result instanceof Promise)void result.catch(()=>void 0);if(result!==false)reportPolicyError(onError,invalidPolicyReturn(result));return false}export function maskCellValue(value,readable,mask){return readable?value:mask}export function resolveCellEditable(params,policy,onError){return resolveCellReadable(params,policy,onError)}

package/dist/collection/components/grid/core/row-drag/drag-safety.js

@@ -0,0 +1 @@
+import{reorderRows}from"./reorder.js";export const POINTER_TYPES=Object.freeze(["mouse","pen","touch"]);export const GESTURE_PHASES=Object.freeze(["idle","pending","armed","yielded"]);export const GESTURE_YIELD_REASONS=Object.freeze(["scroll-intent","hold-too-short","multi-touch","pointer-changed","cancelled"]);export const DEFAULT_DRAG_THRESHOLDS=Object.freeze({mouse:3,pen:5,touch:10,touchHoldTicks:8,scrollAxisRatio:1.5});export const IDLE_GESTURE=Object.freeze({phase:"idle",pointerId:null,pointerType:null,originX:0,originY:0,originTick:0,heldTicks:0,travelled:0,yieldReason:null});export function beginGesture(sample){return{phase:"pending",pointerId:sample.pointerId,pointerType:sample.pointerType,originX:sample.x,originY:sample.y,originTick:sample.tick,heldTicks:0,travelled:0,yieldReason:null}}export function advanceGesture(state,sample,config=DEFAULT_DRAG_THRESHOLDS,scrollAxis="vertical"){if(state.phase!=="pending")return state;const yielded=reason=>({...state,phase:"yielded",yieldReason:reason});if(sample.pointerId!==state.pointerId)return yielded("pointer-changed");if((sample.contacts??1)>1)return yielded("multi-touch");const dx=sample.x-state.originX;const dy=sample.y-state.originY;const travelled=Math.hypot(dx,dy);const heldTicks=Math.max(0,sample.tick-state.originTick);const next={...state,travelled,heldTicks};const pointerType=state.pointerType??"mouse";const threshold=pointerType==="touch"?config.touch:pointerType==="pen"?config.pen:config.mouse;if(travelled<threshold)return next;if(pointerType==="touch"){const along=scrollAxis==="vertical"?Math.abs(dy):scrollAxis==="horizontal"?Math.abs(dx):0;const across=scrollAxis==="vertical"?Math.abs(dx):scrollAxis==="horizontal"?Math.abs(dy):0;if(scrollAxis!=="none"&&along>across*config.scrollAxisRatio){return{...next,phase:"yielded",yieldReason:"scroll-intent"}}if(heldTicks<config.touchHoldTicks){return{...next,phase:"yielded",yieldReason:"hold-too-short"}}}return{...next,phase:"armed"}}export function cancelGesture(state){if(state.phase!=="pending")return state;return{...state,phase:"yielded",yieldReason:"cancelled"}}export function toInlineDelta(dx,direction){return direction==="rtl"?-dx:dx}export const INDENT_INTENTS=Object.freeze(["indent","outdent","none"]);export function resolveIndentIntent(key,direction){if(direction==="rtl")return key==="left"?"indent":"outdent";return key==="left"?"outdent":"indent"}export const DEFAULT_AUTO_SCROLL=Object.freeze({edge:40,maxSpeed:24});export const NO_AUTO_SCROLL=Object.freeze({dx:0,dy:0});function edgeRamp(distance,edge){if(edge<=0)return 0;if(distance>=edge)return 0;if(distance<=0)return 1;return(edge-distance)/edge}export function autoScrollVelocity(box,x,y,config=DEFAULT_AUTO_SCROLL){if(x<box.left||x>box.right||y<box.top||y>box.bottom)return NO_AUTO_SCROLL;const left=edgeRamp(x-box.left,config.edge);const right=edgeRamp(box.right-x,config.edge);const top=edgeRamp(y-box.top,config.edge);const bottom=edgeRamp(box.bottom-y,config.edge);const dx=Math.round((right-left)*config.maxSpeed);const dy=Math.round((bottom-top)*config.maxSpeed);return{dx,dy}}export function canScroll(box,dx,dy){const maxLeft=Math.max(0,box.scrollWidth-box.clientWidth);const maxTop=Math.max(0,box.scrollHeight-box.clientHeight);const horizontally=dx>0?box.scrollLeft<maxLeft:dx<0?box.scrollLeft>0:false;const vertically=dy>0?box.scrollTop<maxTop:dy<0?box.scrollTop>0:false;return horizontally||vertically}export const NO_AUTO_SCROLL_PLAN=Object.freeze({boxId:null,velocity:NO_AUTO_SCROLL,fellThrough:Object.freeze([]),exhausted:false});export function resolveAutoScroll(chain,x,y,config=DEFAULT_AUTO_SCROLL,options={}){const inheritIntent=options.inheritIntent??true;const fellThrough=[];let wanted=false;let inherited=NO_AUTO_SCROLL;for(const box of chain){const own=autoScrollVelocity(box,x,y,config);const velocity={dx:own.dx!==0||!inheritIntent?own.dx:inherited.dx,dy:own.dy!==0||!inheritIntent?own.dy:inherited.dy};if(velocity.dx===0&&velocity.dy===0)continue;wanted=true;const dx=canScroll(box,velocity.dx,0)?velocity.dx:0;const dy=canScroll(box,0,velocity.dy)?velocity.dy:0;if(dx===0&&dy===0){fellThrough.push(box.id);inherited=velocity;continue}return{boxId:box.id,velocity:{dx,dy},fellThrough,exhausted:false}}return{boxId:null,velocity:NO_AUTO_SCROLL,fellThrough,exhausted:wanted}}export const KEYBOARD_REORDER_COMMANDS=Object.freeze(["up","down","top","bottom","page-up","page-down"]);export const KEYBOARD_REORDER_REFUSALS=Object.freeze(["no-grab","already-grabbed","index-out-of-range","unknown-command","at-boundary"]);export const DEFAULT_KEYBOARD_PAGE_SIZE=10;export function createKeyboardReorder(config){const pageSize=config.pageSize??DEFAULT_KEYBOARD_PAGE_SIZE;const getLabel=config.getRowLabel??((row,index)=>config.getRowKey(row,index));let committed=config.rows.slice();let preview=committed;let grabbed=false;let originIndex=-1;let currentIndex=-1;let rowKey=null;let rowLabel="";const announcements=[];const say=announcement=>{announcements.push(announcement);return announcement};const refuse=(reason,detail,announcement=null)=>{if(announcement!==null)say(announcement);return{outcome:"refused",reason,detail,announcement}};const targetFor=command=>{switch(command){case"up":return currentIndex-1;case"down":return currentIndex+1;case"top":return 0;case"bottom":return preview.length-1;case"page-up":return currentIndex-pageSize;case"page-down":return currentIndex+pageSize;default:return null}};return{grab(index){if(grabbed){return refuse("already-grabbed","a row is already grabbed; drop or cancel it first")}if(!Number.isInteger(index)||index<0||index>=committed.length){return refuse("index-out-of-range",`index ${index} is outside the ${committed.length}-row list`)}grabbed=true;originIndex=index;currentIndex=index;preview=committed;rowKey=config.getRowKey(committed[index],index);rowLabel=getLabel(committed[index],index);const announcement=say(dragAnnouncement({kind:"grab",label:rowLabel,position:index+1,total:committed.length}));return{outcome:"moved",fromIndex:index,toIndex:index,rows:preview,announcement}},move(command){if(!grabbed)return refuse("no-grab","no row is grabbed");if(!KEYBOARD_REORDER_COMMANDS.includes(command)){return refuse("unknown-command",`${String(command)} is not a reorder command`)}const raw=targetFor(command);const clamped=Math.max(0,Math.min(preview.length-1,raw));if(clamped===currentIndex){const announcement2=dragAnnouncement({kind:"boundary",label:rowLabel,position:currentIndex+1,total:preview.length,atTop:currentIndex===0});return refuse("at-boundary",`already at index ${currentIndex}`,announcement2)}const insertionIndex=clamped>currentIndex?clamped+1:clamped;const next=reorderRows(preview,currentIndex,insertionIndex);const from=currentIndex;preview=next;currentIndex=clamped;const announcement=say(dragAnnouncement({kind:"move",label:rowLabel,position:clamped+1,total:preview.length,from:from+1}));return{outcome:"moved",fromIndex:from,toIndex:clamped,rows:preview,announcement}},drop(){if(!grabbed){return{outcome:"refused",reason:"no-grab",detail:"no row is grabbed",announcement:null}}const from=originIndex;const to=currentIndex;committed=preview;grabbed=false;const announcement=say(dragAnnouncement({kind:"drop",label:rowLabel,position:to+1,total:committed.length}));originIndex=-1;currentIndex=-1;rowKey=null;return{outcome:"dropped",rows:committed,fromIndex:from,toIndex:to,announcement}},cancel(){if(!grabbed){return{outcome:"refused",reason:"no-grab",detail:"no row is grabbed",announcement:null}}const from=originIndex;preview=committed;grabbed=false;const announcement=say(dragAnnouncement({kind:"cancel",label:rowLabel,position:from+1,total:committed.length}));const to=currentIndex;originIndex=-1;currentIndex=-1;rowKey=null;return{outcome:"dropped",rows:committed,fromIndex:to,toIndex:from,announcement}},state:()=>({grabbed,originIndex,currentIndex,rows:preview,rowKey}),rows:()=>committed,announcements:()=>announcements}}export const ANNOUNCEMENT_KINDS=Object.freeze(["grab","move","drop","cancel","boundary","orphaned"]);export const ANNOUNCEMENT_POLITENESS=Object.freeze(["polite","assertive"]);export function dragAnnouncement(input){const{label,position,total}=input;switch(input.kind){case"grab":return{kind:"grab",politeness:"assertive",text:`${label}, row ${position} of ${total}, grabbed. Use the arrow keys to move it, Enter to drop, Escape to cancel.`};case"move":return{kind:"move",politeness:"polite",text:`${label} moved from row ${String(input.from??position)} to row ${position} of ${total}.`};case"drop":return{kind:"drop",politeness:"assertive",text:`${label} dropped at row ${position} of ${total}.`};case"cancel":return{kind:"cancel",politeness:"assertive",text:`Move cancelled. ${label} returned to row ${position} of ${total}.`};case"boundary":return{kind:"boundary",politeness:"polite",text:`${label} is already at the ${input.atTop===true?"top":"bottom"} of the list, row ${position} of ${total}.`};case"orphaned":return{kind:"orphaned",politeness:"assertive",text:`Move cancelled: ${describeOrphanCause(input.cause??"pointer-capture-lost")}. ${label} returned to row ${position} of ${total}.`};default:return{kind:"move",politeness:"polite",text:""}}}export const DRAG_ORPHAN_CAUSES=Object.freeze(["pointer-capture-lost","pointer-cancel","element-disconnected","permission-revoked","document-hidden","window-blur","watchdog-timeout","zone-unregistered","context-menu","data-source-replaced","controller-disposed"]);export const DRAG_ORPHAN_END_REASONS=Object.freeze({"pointer-capture-lost":"capture-lost","pointer-cancel":"pointer-cancel","element-disconnected":"disconnect","permission-revoked":"cancel","document-hidden":"blur","window-blur":"blur","watchdog-timeout":"pointer-cancel","zone-unregistered":"zone-removed","context-menu":"cancel","data-source-replaced":"data-replaced","controller-disposed":"dispose"});function describeOrphanCause(cause){switch(cause){case"pointer-capture-lost":return"the pointer was released unexpectedly";case"pointer-cancel":return"the system cancelled the gesture";case"element-disconnected":return"the row is no longer on screen";case"permission-revoked":return"you no longer have permission to move this row";case"document-hidden":return"the page was hidden";case"window-blur":return"the window lost focus";case"watchdog-timeout":return"the drag stopped responding";case"zone-unregistered":return"the drop target was removed";case"context-menu":return"a menu opened";case"data-source-replaced":return"the data changed";case"controller-disposed":return"the grid was closed";default:return"the drag ended unexpectedly"}}export const DEFAULT_WATCHDOG_TICKS=60;function emptyCauseCounts(){const counts={};for(const cause of DRAG_ORPHAN_CAUSES)counts[cause]=0;return counts}export function createDragSafetyMonitor(config={}){const watchdogTicks=config.watchdogTicks??DEFAULT_WATCHDOG_TICKS;const entries=new Map;let tracked=0;let aborts=0;let ignored=0;let redundant=0;let sinkThrows=0;let swept=0;let watchdogTimeouts=0;const abortsByCause=emptyCauseCounts();const abort=(entry,cause)=>{entry.causes=[...entry.causes,cause];const reason=DRAG_ORPHAN_END_REASONS[cause];let threw=false;try{entry.sink.abort(reason,cause)}catch{threw=true;sinkThrows+=1}entries.delete(entry.dragId);aborts+=1;abortsByCause[cause]+=1;if(threw)return true;return true};return{track(dragId,sink,pointerId=null){if(typeof dragId!=="string"||dragId===""||entries.has(dragId))return false;entries.set(dragId,{dragId,sink,pointerId,idleTicks:0,causes:[]});tracked+=1;return true},heartbeat(dragId){const entry=entries.get(dragId);if(entry===void 0){ignored+=1;return}entry.idleTicks=0},signal(cause,options={}){if(!DRAG_ORPHAN_CAUSES.includes(cause)){ignored+=1;return[]}const aborted=[];if(options.dragId!==void 0){const entry=entries.get(options.dragId);if(entry===void 0){redundant+=1;return[]}if(options.pointerId!==void 0&&entry.pointerId!==null&&entry.pointerId!==options.pointerId){ignored+=1;return[]}if(abort(entry,cause))aborted.push(entry.dragId);return aborted}for(const entry of[...entries.values()]){if(options.pointerId!==void 0&&entry.pointerId!==null&&entry.pointerId!==options.pointerId){ignored+=1;continue}if(abort(entry,cause))aborted.push(entry.dragId)}return aborted},tick(){const aborted=[];for(const entry of[...entries.values()]){entry.idleTicks+=1;if(entry.idleTicks>=watchdogTicks){watchdogTimeouts+=1;if(abort(entry,"watchdog-timeout"))aborted.push(entry.dragId)}}return aborted},sweep(){const cleared=[];for(const entry of[...entries.values()]){let alive=true;try{alive=entry.sink.alive()}catch{sinkThrows+=1;alive=false}if(!alive){entries.delete(entry.dragId);cleared.push(entry.dragId);continue}if(entry.causes.length>0){swept+=1;abort(entry,entry.causes[entry.causes.length-1]);cleared.push(entry.dragId)}}return cleared},stuckDrags(){const stuck=[];for(const entry of entries.values()){let alive=true;try{alive=entry.sink.alive()}catch{alive=false}if(alive&&entry.causes.length>0)stuck.push(entry.dragId)}return stuck},live:()=>[...entries.values()].map(entry=>({dragId:entry.dragId,pointerId:entry.pointerId,idleTicks:entry.idleTicks,causes:[...entry.causes]})),stats:()=>({tracked,live:entries.size,aborts,abortsByCause:{...abortsByCause},ignored,redundant,sinkThrows,swept,watchdogTimeouts}),abortAll(cause="controller-disposed"){const aborted=[];for(const entry of[...entries.values()]){if(abort(entry,cause))aborted.push(entry.dragId)}return aborted}}}export function rowDragAbortSink(controller){return{abort:reason=>{controller.end(reason)},alive:()=>controller.session()?.phase==="dragging"}}export function dragSafetyReport(monitor,watchdogTicks=DEFAULT_WATCHDOG_TICKS){const stats=monitor.stats();const topCauses=Object.entries(stats.abortsByCause).filter(([,count])=>count>0).sort((a,b)=>b[1]-a[1]||(a[0]<b[0]?-1:1)).map(([cause,count])=>({cause,count}));return{live:stats.live,stuck:monitor.stuckDrags(),aborts:stats.aborts,topCauses,watchdogTicks,stats}}

package/dist/collection/components/grid/core/row-drag/drop-zones.js

@@ -0,0 +1 @@
+export const ROW_DROP_ZONE_KINDS=Object.freeze(["grid","external"]);export const ROW_TRANSFER_MODES=Object.freeze(["move","copy"]);export const ROW_TRANSFER_ATOMICITIES=Object.freeze(["all-or-nothing","best-effort"]);export const ROW_DUPLICATE_ID_POLICIES=Object.freeze(["refuse","skip","replace"]);export const ROW_FIELD_TYPES=Object.freeze(["string","number","boolean","date","any"]);export const ROW_TRANSFER_REFUSAL_REASONS=Object.freeze(["unknown-zone","zone-removed","zone-not-accepting","wrong-kind","self-transfer","schema-mismatch","permission-denied","permission-error","duplicate-id","missing-id","empty-transfer","source-row-missing","insert-out-of-range","partial-failure","already-settled","adapter-error","key-error"]);export const ROW_TRANSFER_ENTRY_STATUSES=Object.freeze(["transferred","replaced","refused"]);export const ROW_ZONE_REGISTRATION_REFUSALS=Object.freeze(["duplicate-zone-id","invalid-zone-id","invalid-kind","grid-zone-incomplete","external-zone-owns-rows"]);export const ROW_SCHEMA_ISSUE_KINDS=Object.freeze(["missing-required","wrong-type","extra-field","not-an-object"]);function typeOfValue(value){if(value===null)return"null";if(Array.isArray(value))return"array";if(value instanceof Date)return"date";return typeof value}function matchesFieldType(value,type){switch(type){case"any":return true;case"string":return typeof value==="string";case"number":return typeof value==="number"&&Number.isFinite(value);case"boolean":return typeof value==="boolean";case"date":return value instanceof Date&&!Number.isNaN(value.getTime());default:return false}}export function checkRowSchema(row,schema){if(row===null||typeof row!=="object"||Array.isArray(row)){return[{kind:"not-an-object",field:"",expected:null,actual:typeOfValue(row)}]}const issues=[];const declared=new Set;const record=row;for(const spec of schema.fields){declared.add(spec.field);const present=Object.prototype.hasOwnProperty.call(record,spec.field)&&record[spec.field]!==void 0;if(!present){if(spec.required){issues.push({kind:"missing-required",field:spec.field,expected:spec.type,actual:"undefined"})}continue}if(!matchesFieldType(record[spec.field],spec.type)){issues.push({kind:"wrong-type",field:spec.field,expected:spec.type,actual:typeOfValue(record[spec.field])})}}if(!schema.allowExtraFields){for(const field of Object.keys(record)){if(!declared.has(field)){issues.push({kind:"extra-field",field,expected:null,actual:typeOfValue(record[field])})}}}return issues}export const ALLOW_ROW_DROP=Object.freeze({allow:true});export function createRowDropZoneRegistry(){const zones=new Map;let generation=0;let added=0;let removed=0;let addRefusals=0;const refuse=(zoneId,reason,detail)=>{addRefusals+=1;return{outcome:"refused",zoneId,reason,detail}};return{add(zone){const zoneId=zone?.id;if(typeof zoneId!=="string"||zoneId===""){return refuse(String(zoneId),"invalid-zone-id","a zone id must be a non-empty string")}if(zone.kind!=="grid"&&zone.kind!=="external"){return refuse(zoneId,"invalid-kind",`kind must be 'grid' or 'external', got ${String(zone.kind)}`)}if(zones.has(zoneId)){return refuse(zoneId,"duplicate-zone-id",`zone ${zoneId} is already registered`)}if(zone.kind==="grid"&&(typeof zone.rows!=="function"||typeof zone.getRowKey!=="function")){return refuse(zoneId,"grid-zone-incomplete","a grid zone must supply rows() and getRowKey(); without them it cannot receive a transfer")}if(zone.kind==="external"&&typeof zone.rows==="function"){return refuse(zoneId,"external-zone-owns-rows","an external zone owns no rows: the host owns whatever it does with the payload")}generation+=1;added+=1;zones.set(zoneId,{zone,registeredAt:generation});return{outcome:"added",zoneId,generation}},remove(zoneId){if(!zones.has(zoneId))return false;zones.delete(zoneId);generation+=1;removed+=1;return true},get:zoneId=>zones.get(zoneId)??null,list:()=>[...zones.values()],generation:()=>generation,stats:()=>{let gridZones=0;let externalZones=0;for(const registered of zones.values()){if(registered.zone.kind==="grid")gridZones+=1;else externalZones+=1}return{zones:zones.size,gridZones,externalZones,added,removed,addRefusals,generation}}}}export function rowTransferRequestFromDragItem(item,targetZoneId,options={}){return{transferId:options.transferId??item.dragId,sourceZoneId:item.sourceZoneId,targetZoneId,mode:options.mode??"move",rowKeys:item.rowKeys,insertIndex:options.insertIndex,atomicity:options.atomicity,duplicateIds:options.duplicateIds,context:options.context}}const refusedEntry=(rowKey,reason,detail,sourceIndex=null,schemaIssues=[])=>({rowKey,status:"refused",reason,detail,schemaIssues,sourceIndex,targetIndex:null});const planRefusal=(reason,detail,entries=[])=>({outcome:"refused",reason,detail,entries});function safely(run){try{return{ok:true,value:run()}}catch(error){return{ok:false,error:error instanceof Error?error.message:String(error)}}}const threw=result=>!result.ok;export function planRowTransfer(registry,request){const{sourceZoneId,targetZoneId,mode,rowKeys,atomicity="all-or-nothing",duplicateIds="refuse"}=request;const transferId=request.transferId??`${sourceZoneId}->${targetZoneId}`;if(sourceZoneId===targetZoneId){return planRefusal("self-transfer",`zone ${sourceZoneId} is both source and target; a reorder inside one grid is Day 72 managed drag`)}const source=registry.get(sourceZoneId);if(source===null)return planRefusal("unknown-zone",`no zone registered as ${sourceZoneId}`);if(source.zone.kind!=="grid"){return planRefusal("wrong-kind",`zone ${sourceZoneId} is external and owns no rows to transfer`)}const target=registry.get(targetZoneId);if(target===null)return planRefusal("unknown-zone",`no zone registered as ${targetZoneId}`);if(target.zone.accepting===false){return planRefusal("zone-not-accepting",`zone ${targetZoneId} is registered as not accepting drops`)}if(mode!=="move"&&mode!=="copy"){return planRefusal("wrong-kind",`mode must be 'move' or 'copy', got ${String(mode)}`)}if(!Array.isArray(rowKeys)||rowKeys.length===0){return planRefusal("empty-transfer","no row keys were named")}const sourceRowsRead=safely(()=>source.zone.rows());if(threw(sourceRowsRead)){return planRefusal("source-row-missing",`source rows() threw: ${sourceRowsRead.error}`)}const sourceRows=sourceRowsRead.value;const getSourceKey=source.zone.getRowKey;const sourceIndexByKey=new Map;for(let index=0;index<sourceRows.length;index+=1){const key=safely(()=>getSourceKey(sourceRows[index],index));if(threw(key)){return planRefusal("key-error",`source getRowKey threw at index ${index}: ${key.error}`)}if(!sourceIndexByKey.has(key.value))sourceIndexByKey.set(key.value,index)}const targetIsGrid=target.zone.kind==="grid";let targetRows=[];const targetKeys=new Set;if(targetIsGrid){const read=safely(()=>target.zone.rows());if(threw(read))return planRefusal("unknown-zone",`target rows() threw: ${read.error}`);targetRows=read.value;const getTargetKey=target.zone.getRowKey;for(let index=0;index<targetRows.length;index+=1){const key=safely(()=>getTargetKey(targetRows[index],index));if(threw(key)){return planRefusal("key-error",`target getRowKey threw at index ${index}: ${key.error}`)}targetKeys.add(key.value)}}const insertIndex=request.insertIndex??targetRows.length;if(targetIsGrid&&(!Number.isInteger(insertIndex)||insertIndex<0||insertIndex>targetRows.length)){return planRefusal("insert-out-of-range",`insertIndex ${insertIndex} is outside [0, ${targetRows.length}] of zone ${targetZoneId}`)}const entries=[];const payload=[];const seenInBatch=new Set;for(const rowKey of rowKeys){if(typeof rowKey!=="string"||rowKey===""){entries.push(refusedEntry(String(rowKey),"missing-id","a transferred row needs a non-empty stable key"));payload.push(void 0);continue}if(seenInBatch.has(rowKey)){entries.push(refusedEntry(rowKey,"duplicate-id",`${rowKey} appears twice in the same transfer`));payload.push(void 0);continue}seenInBatch.add(rowKey);const sourceIndex=sourceIndexByKey.get(rowKey);if(sourceIndex===void 0){entries.push(refusedEntry(rowKey,"source-row-missing",`${rowKey} is not in zone ${sourceZoneId} any more`));payload.push(void 0);continue}const original=sourceRows[sourceIndex];let row=original;if(typeof target.zone.adapt==="function"){const adapted=safely(()=>target.zone.adapt(original,sourceZoneId));if(threw(adapted)){entries.push(refusedEntry(rowKey,"adapter-error",`adapt threw: ${adapted.error}`,sourceIndex));payload.push(void 0);continue}row=adapted.value}if(target.zone.schema!==void 0){const issues=checkRowSchema(row,target.zone.schema);if(issues.length>0){entries.push(refusedEntry(rowKey,"schema-mismatch",`${issues.length} issue(s) against schema ${target.zone.schema.id}`,sourceIndex,issues));payload.push(void 0);continue}}if(typeof target.zone.permit==="function"){const verdict=safely(()=>target.zone.permit({sourceZoneId,targetZoneId,mode,rowKey,row,context:request.context}));if(threw(verdict)){entries.push(refusedEntry(rowKey,"permission-error",`permit threw: ${verdict.error}`,sourceIndex));payload.push(void 0);continue}if(verdict.value?.allow!==true){entries.push(refusedEntry(rowKey,"permission-denied",verdict.value?.allow===false?verdict.value.detail:"permit returned a malformed verdict",sourceIndex));payload.push(void 0);continue}}if(targetIsGrid&&targetKeys.has(rowKey)){if(duplicateIds==="replace"){entries.push({rowKey,status:"replaced",reason:null,detail:`${rowKey} already exists in ${targetZoneId} and is replaced in place`,schemaIssues:[],sourceIndex,targetIndex:null});payload.push(row);continue}const detail=duplicateIds==="skip"?`${rowKey} already exists in ${targetZoneId} and is skipped`:`${rowKey} already exists in ${targetZoneId}`;entries.push(refusedEntry(rowKey,"duplicate-id",detail,sourceIndex));payload.push(void 0);continue}entries.push({rowKey,status:"transferred",reason:null,detail:"",schemaIssues:[],sourceIndex,targetIndex:null});payload.push(row)}const refused=entries.filter(entry=>entry.status==="refused");if(atomicity==="all-or-nothing"&&refused.length>0){const first=refused[0];return planRefusal("partial-failure",`${refused.length} of ${entries.length} rows were refused (first: ${first.rowKey} — ${String(first.reason)}); the transfer is all-or-nothing so nothing moves`,entries)}if(refused.length===entries.length){return planRefusal("partial-failure",`every one of the ${entries.length} rows was refused; there is nothing to transfer`,entries)}const removesFromSource=mode==="move"&&(targetIsGrid||target.zone.consumes===true);return{outcome:"planned",plan:{transferId,sourceZoneId,targetZoneId,targetKind:target.zone.kind,mode,atomicity,duplicateIds,insertIndex,generation:registry.generation(),entries,payload,removesFromSource}}}const commitRefusal=(reason,detail,entries)=>({outcome:"refused",reason,detail,entries});export function commitRowTransfer(registry,plan){if(registry.generation()!==plan.generation){return commitRefusal("zone-removed",`the zone registry moved from generation ${plan.generation} to ${registry.generation()} between planning and committing; re-plan rather than write into a target that may be gone`,plan.entries)}const source=registry.get(plan.sourceZoneId);const target=registry.get(plan.targetZoneId);if(source===null)return commitRefusal("zone-removed",`source zone ${plan.sourceZoneId} is gone`,plan.entries);if(target===null)return commitRefusal("zone-removed",`target zone ${plan.targetZoneId} is gone`,plan.entries);if(target.zone.accepting===false){return commitRefusal("zone-not-accepting",`zone ${plan.targetZoneId} stopped accepting drops`,plan.entries)}const sourceRowsRead=safely(()=>source.zone.rows());if(threw(sourceRowsRead)){return commitRefusal("source-row-missing",`source rows() threw: ${sourceRowsRead.error}`,plan.entries)}const sourceRowsBefore=sourceRowsRead.value;const getSourceKey=source.zone.getRowKey;const sourceIndexByKey=new Map;for(let index=0;index<sourceRowsBefore.length;index+=1){const key=safely(()=>getSourceKey(sourceRowsBefore[index],index));if(threw(key))return commitRefusal("key-error",`source getRowKey threw: ${key.error}`,plan.entries);if(!sourceIndexByKey.has(key.value))sourceIndexByKey.set(key.value,index)}const movingKeys=[];const movingRows=[];const settled=[];const vanished=[];for(let i=0;i<plan.entries.length;i+=1){const entry=plan.entries[i];if(entry.status==="refused"){settled.push(entry);continue}if(!sourceIndexByKey.has(entry.rowKey)){const gone=refusedEntry(entry.rowKey,"source-row-missing",`${entry.rowKey} left zone ${plan.sourceZoneId} between planning and committing`,null);settled.push(gone);vanished.push(gone);continue}settled.push(entry);movingKeys.push(entry.rowKey);movingRows.push(plan.payload[i])}if(vanished.length>0&&plan.atomicity==="all-or-nothing"){return commitRefusal("partial-failure",`${vanished.length} row(s) left the source between planning and committing; the transfer is all-or-nothing so nothing moves`,settled)}if(movingKeys.length===0){return commitRefusal("partial-failure","no row survived to the commit; nothing moves",settled)}const moving=new Set(movingKeys);const sourceRowsAfter=plan.removesFromSource?sourceRowsBefore.filter((row,index)=>{const key=getSourceKey(row,index);return!moving.has(key)||sourceIndexByKey.get(key)!==index}):sourceRowsBefore;const finalEntries=[];let targetResult;if(target.zone.kind==="external"){targetResult={kind:"external",zoneId:plan.targetZoneId,delivered:movingRows,consumed:plan.removesFromSource};let delivered=0;for(const entry of settled){if(entry.status==="refused"){finalEntries.push(entry);continue}finalEntries.push({...entry,targetIndex:delivered});delivered+=1}}else{const targetRowsRead=safely(()=>target.zone.rows());if(threw(targetRowsRead)){return commitRefusal("unknown-zone",`target rows() threw: ${targetRowsRead.error}`,settled)}const targetRowsBefore=targetRowsRead.value;const getTargetKey=target.zone.getRowKey;const targetIndexByKey=new Map;for(let index=0;index<targetRowsBefore.length;index+=1){const key=safely(()=>getTargetKey(targetRowsBefore[index],index));if(threw(key))return commitRefusal("key-error",`target getRowKey threw: ${key.error}`,settled);if(!targetIndexByKey.has(key.value))targetIndexByKey.set(key.value,index)}const next=targetRowsBefore.slice();const inserted=[];const placedAt=new Map;let movingCursor=0;for(const entry of settled){if(entry.status==="refused")continue;const row=movingRows[movingCursor];movingCursor+=1;const existing=targetIndexByKey.get(entry.rowKey);if(entry.status==="replaced"&&existing!==void 0){next[existing]=row;placedAt.set(entry.rowKey,existing)}else{inserted.push({rowKey:entry.rowKey,row})}}const at=Math.min(plan.insertIndex,next.length);next.splice(at,0,...inserted.map(item=>item.row));for(let i=0;i<inserted.length;i+=1){placedAt.set(inserted[i].rowKey,at+i)}for(const[rowKey,index]of placedAt){if(inserted.some(item=>item.rowKey===rowKey))continue;placedAt.set(rowKey,index>=at?index+inserted.length:index)}targetResult={kind:"grid",zoneId:plan.targetZoneId,rowsBefore:targetRowsBefore,rowsAfter:next};for(const entry of settled){finalEntries.push(entry.status==="refused"?entry:{...entry,targetIndex:placedAt.get(entry.rowKey)??null})}}const transferred=finalEntries.filter(entry=>entry.status!=="refused");const refused=finalEntries.filter(entry=>entry.status==="refused");return{outcome:"committed",commit:{transferId:plan.transferId,mode:plan.mode,sourceZoneId:plan.sourceZoneId,sourceRowsBefore,sourceRowsAfter,target:targetResult,transferred,refused,entries:finalEntries}}}export const ROW_TRANSFER_APPLY_OUTCOMES=Object.freeze(["applied","reverted","compromised"]);export function applyRowTransfer(commit,sinks){const targetWrite=safely(()=>sinks.applyTarget(commit.target,commit));if(threw(targetWrite)){return{outcome:"reverted",failedSide:"target",error:targetWrite.error,targetUndone:false}}const sourceChanged=commit.sourceRowsAfter!==commit.sourceRowsBefore;if(!sourceChanged){return{outcome:"applied",sourceWritten:false,targetWritten:true}}const sourceWrite=safely(()=>sinks.applySource(commit.sourceRowsAfter,commit));if(!threw(sourceWrite)){return{outcome:"applied",sourceWritten:true,targetWritten:true}}if(typeof sinks.revertTarget!=="function"){return{outcome:"compromised",failedSide:"source",error:sourceWrite.error,revertError:"no revertTarget sink was supplied, so the target write cannot be undone"}}const revert=safely(()=>sinks.revertTarget(commit.target,commit));if(!threw(revert)){return{outcome:"reverted",failedSide:"source",error:sourceWrite.error,targetUndone:true}}return{outcome:"compromised",failedSide:"source",error:sourceWrite.error,revertError:revert.error}}export function rowTransferReport(commit){const refusalsByReason={};for(const entry of commit.refused){if(entry.reason===null)continue;refusalsByReason[entry.reason]=(refusalsByReason[entry.reason]??0)+1}return{transferId:commit.transferId,mode:commit.mode,sourceZoneId:commit.sourceZoneId,targetZoneId:commit.target.zoneId,targetKind:commit.target.kind,transferred:commit.transferred.filter(entry=>entry.status==="transferred").length,replaced:commit.transferred.filter(entry=>entry.status==="replaced").length,refused:commit.refused.length,refusalsByReason,sourceDelta:commit.sourceRowsAfter.length-commit.sourceRowsBefore.length,targetDelta:commit.target.kind==="grid"?commit.target.rowsAfter.length-commit.target.rowsBefore.length:null}}

package/dist/collection/components/grid/core/row-drag/reorder.js

@@ -0,0 +1 @@
+export function beginRowDrag(sourceIndex){return{sourceIndex,overIndex:sourceIndex,position:"below"}}export function updateRowDragOver(state,overIndex,position){if(state.overIndex===overIndex&&state.position===position)return state;return{sourceIndex:state.sourceIndex,overIndex,position}}export function computeInsertionIndex(overIndex,position){if(overIndex===null)return null;return position==="above"?overIndex:overIndex+1}export function dropInsertionIndex(state){return computeInsertionIndex(state.overIndex,state.position)}export function isNoopDrop(sourceIndex,insertionIndex){if(insertionIndex===null)return true;return insertionIndex===sourceIndex||insertionIndex===sourceIndex+1}export function reorderRows(rows,sourceIndex,insertionIndex){if(!Number.isInteger(sourceIndex)||sourceIndex<0||sourceIndex>=rows.length){return rows}if(insertionIndex===null)return rows;const insert=insertionIndex<0?0:insertionIndex>rows.length?rows.length:insertionIndex;if(isNoopDrop(sourceIndex,insert))return rows;const next=rows.slice();const[moved]=next.splice(sourceIndex,1);const adjusted=insert>sourceIndex?insert-1:insert;next.splice(adjusted,0,moved);return next}

package/dist/collection/components/grid/core/row-drag/row-drag-chunk.js

@@ -0,0 +1 @@
+export*from"./unmanaged-drag.js";export*from"./drop-zones.js";export*from"./drag-safety.js";export*from"./row-drag-facade.js";

package/dist/collection/components/grid/core/row-drag/row-drag-facade.js

@@ -0,0 +1 @@
+import{createRowDragController,rowDragReport}from"./unmanaged-drag.js";import{applyRowTransfer,commitRowTransfer,createRowDropZoneRegistry,planRowTransfer,rowTransferReport,rowTransferRequestFromDragItem}from"./drop-zones.js";import{DEFAULT_DRAG_THRESHOLDS,DEFAULT_WATCHDOG_TICKS,IDLE_GESTURE,advanceGesture,beginGesture,cancelGesture,createDragSafetyMonitor,createKeyboardReorder,dragAnnouncement,dragSafetyReport,resolveAutoScroll,rowDragAbortSink}from"./drag-safety.js";const isPointerSession=controller=>controller!==null&&controller.mode==="unmanaged";export function createRowDragFacade(host,config={}){const thresholds={...DEFAULT_DRAG_THRESHOLDS,...config.thresholds??{}};const watchdogTicks=config.watchdogTicks??DEFAULT_WATCHDOG_TICKS;const monitor=createDragSafetyMonitor({watchdogTicks});const registry=createRowDropZoneRegistry();const zoneMeta=new Map;let gesture=IDLE_GESTURE;let pending=null;let controller=null;let activeTargetZone=null;let lastAutoScroll=null;let keyboard=null;let keyboardOrigin=-1;let ghostUp=false;let disposed=false;let tickCounter=0;let sessionSeq=0;const ownZone=host.zoneId();registry.add({id:ownZone,kind:"grid",rows:()=>host.rows(),getRowKey:(row,index)=>host.rowKey(row,index)});const residue=()=>controller===null?[]:controller.residue().slice();let reparentTarget=null;let reparentHover=null;const endReparent=()=>{if(host.reparent!==void 0&&(reparentTarget!==null||reparentHover!==null||controller!==null)){host.reparent.end()}reparentTarget=null;reparentHover=null};const clearPaint=()=>{host.paintTarget(null,null);if(ghostUp){host.ghost.destroy();ghostUp=false}};const finish=(reason,cause)=>{if(controller===null)return;endReparent();const session=controller.session();const item=session?.item??null;const dragId=session?.dragId??"";const ended=controller.end(reason);clearPaint();activeTargetZone=null;if(ended.ended&&reason!=="drop"){host.emit({kind:"rowDragCancel",detail:{dragId,item,reason,cause,residue:ended.residue.slice()}});if(item!==null){host.announce(dragAnnouncement({kind:"cancel",label:host.rowLabel(item.data,item.startIndex),position:item.startIndex+1,total:host.displayRows().length}))}}controller=null;gesture=IDLE_GESTURE;pending=null};const startSession=(rowIndex,extra,sample)=>{const rows=host.displayRows();if(!Number.isInteger(rowIndex)||rowIndex<0||rowIndex>=rows.length){return{status:"refused",reason:"index-out-of-range",detail:`row ${rowIndex} is outside the ${rows.length} displayed rows`}}const zoneIds=registry.list().map(entry=>entry.zone.id);sessionSeq+=1;monitor.sweep();const next=createRowDragController({mode:"unmanaged",id:`${ownZone}/${sessionSeq}`,droppableZoneIds:zoneIds});const extraKeys=extra.filter(index=>index!==rowIndex&&index>=0&&index<rows.length);const started=next.start({zoneId:ownZone,rowKey:host.rowKey(rows[rowIndex],rowIndex),rowIndex,data:rows[rowIndex],extraKeys:extraKeys.map(index=>host.rowKey(rows[index],index)),extraRows:extraKeys.map(index=>rows[index])});if(started.outcome==="refused"){next.dispose();return{status:"refused",reason:started.reason,detail:started.detail}}controller=next;monitor.track(started.item.dragId,rowDragAbortSink(next),sample?.pointerId??null);const label=host.rowLabel(started.item.data,rowIndex);const ghostLabel=config.dragText!==void 0?config.dragText({count:started.item.rowKeys.length,label}):started.item.rowKeys.length>1?`${label} (+${started.item.rowKeys.length-1})`:label;if(sample!==null){host.ghost.create(ghostLabel,sample.x,sample.y);ghostUp=true}host.paintTarget(null,rowIndex);host.emit({kind:"rowDragEnter",detail:{dragId:started.item.dragId,item:started.item,target:null,insertionIndex:null,keyboard:sample===null}});host.announce(dragAnnouncement({kind:"grab",label,position:rowIndex+1,total:rows.length}));return{status:"armed",dragId:started.item.dragId,rowKey:started.item.rowKey,rowIndex,rowKeys:started.item.rowKeys}};const applyMove=sample=>{if(controller===null)return;monitor.heartbeat(controller.session()?.dragId??"");if(ghostUp)host.ghost.move(sample.x,sample.y);const window2=host.window();const applied=controller.applyWindow({firstIndex:window2.firstIndex,keys:window2.keys});const session=controller.session();if(session===null)return;if(applied.targetInvalidated){host.emit({kind:"rowDragLeave",detail:{dragId:session.dragId,item:session.item,target:applied.target,insertionIndex:null,stale:true,keyboard:false}})}const own=host.rowIndexAtPoint(sample.x,sample.y);let result;if(own!==null){activeTargetZone=ownZone;const rows=host.displayRows();const key=own.index>=0&&own.index<rows.length?host.rowKey(rows[own.index],own.index):null;if(host.reparent!==void 0){const probed=host.reparent.probe(own.index,sample.x,sample.y,session.item.rowKeys);reparentTarget=probed.intoTargetId;reparentHover=probed.hoverNodeId}result=controller.moveOver(ownZone,own.index,own.position,key)}else{reparentTarget=null;reparentHover=null;const zone=host.zoneAtPoint(sample.x,sample.y);if(zone!==null&&registry.get(zone.zoneId)!==null){activeTargetZone=zone.zoneId;result=controller.moveOver(zone.zoneId,zone.rowIndex,zone.position,zone.rowKey)}else{activeTargetZone=null;result=controller.moveOut()}}if(result.outcome==="moved"){const paintPosition=reparentTarget!==null&&result.target.zoneId===ownZone?"into":result.target.position;host.paintTarget({zoneId:result.target.zoneId,rowIndex:result.target.rowIndex,position:paintPosition},session.item.startIndex);host.emit({kind:"rowDragMove",detail:{dragId:session.dragId,item:session.item,target:result.target,insertionIndex:result.insertionIndex,keyboard:false}})}else if(result.outcome==="left"){host.paintTarget(null,session.item.startIndex);host.emit({kind:"rowDragLeave",detail:{dragId:session.dragId,item:session.item,target:null,insertionIndex:null,stale:false,keyboard:false}})}const box=host.viewportScrollBox();if(box!==null){lastAutoScroll=resolveAutoScroll([box],sample.x,sample.y);const active=lastAutoScroll.boxId!==null;controller.setAutoScrolling(active);if(active)host.scrollViewportBy(lastAutoScroll.velocity.dx,lastAutoScroll.velocity.dy)}};const transferTo=(item,target)=>{const meta=zoneMeta.get(target.zoneId);const request=rowTransferRequestFromDragItem(item,target.zoneId,{mode:meta?.mode??"move",insertIndex:target.rowIndex===null?void 0:target.rowIndex+(target.position==="below"?1:0),atomicity:meta?.atomicity,duplicateIds:meta?.duplicateIds});const planned=planRowTransfer(registry,request);if(planned.outcome==="refused"){return{report:null,outcome:null}}const committed=commitRowTransfer(registry,planned.plan);if(committed.outcome==="refused")return{report:null,outcome:null};const commit=committed.commit;const outcome=applyRowTransfer(commit,{applySource:rows=>host.setRows(rows),applyTarget:(targetResult,done)=>{if(targetResult.kind==="grid")meta?.applyTarget?.(targetResult.rowsAfter);meta?.onDrop?.(targetResult,done)},revertTarget:targetResult=>{if(targetResult.kind==="grid")meta?.revertTarget?.(targetResult.rowsBefore)}});const report=rowTransferReport(commit);host.emit({kind:"rowsTransferred",detail:{transferId:commit.transferId,sourceZoneId:commit.sourceZoneId,targetZoneId:target.zoneId,mode:commit.mode,report,outcome,commit}});return{report,outcome}};const facade={pointerDown(input){if(disposed)return{status:"refused",reason:"disposed",detail:"the drag facade was disposed with its element"};if(controller!==null)return{status:"refused",reason:"already-dragging",detail:"a drag session is already live"};if(keyboard!==null)return{status:"refused",reason:"already-grabbed",detail:"a keyboard grab is live; drop or cancel it first"};const rows=host.displayRows();if(!Number.isInteger(input.rowIndex)||input.rowIndex<0||input.rowIndex>=rows.length){return{status:"refused",reason:"index-out-of-range",detail:`row ${input.rowIndex} is outside the ${rows.length} displayed rows`}}gesture=beginGesture(input.sample);pending={rowIndex:input.rowIndex,extra:config.multiRow===true?input.extraRowIndices??[]:[]};return{status:"pending",rowIndex:input.rowIndex,rowKey:host.rowKey(rows[input.rowIndex],input.rowIndex)}},pointerMove(sample){if(disposed)return;if(controller===null){if(pending===null||gesture.phase==="idle")return;gesture=advanceGesture(gesture,sample,thresholds,"vertical");if(gesture.phase==="armed"){const started=startSession(pending.rowIndex,pending.extra,sample);if(started.status!=="armed"){gesture=IDLE_GESTURE;pending=null;return}applyMove(sample)}else if(gesture.phase==="yielded"){gesture=IDLE_GESTURE;pending=null}return}applyMove(sample)},pointerUp(_sample){if(disposed)return;if(controller===null){gesture=cancelGesture(gesture);gesture=IDLE_GESTURE;pending=null;return}const session=controller.session();const liveTarget=session?.target??null;const dropped=controller.drop();const rowless=dropped.outcome==="refused"&&dropped.reason==="no-target"&&session!==null&&liveTarget!==null&&liveTarget.zoneId!==ownZone;if(dropped.outcome==="refused"&&!rowless||session===null){finish(dropped.outcome==="refused"&&dropped.reason==="no-target"?"no-target":"cancel","no-target");return}const item=session.item;const target=rowless?liveTarget:dropped.target;const suggested=rowless?null:dropped.suggestedInsertionIndex;let transfer={report:null,outcome:null};let reparented=null;if(reparentTarget!==null&&target.zoneId===ownZone&&host.reparent!==void 0){reparented={targetNodeId:reparentTarget,applied:host.reparent.drop(reparentTarget,item.rowKeys)}}const delegated=reparented===null&&target.zoneId===ownZone;if(target.zoneId!==ownZone)transfer=transferTo(item,target);const ended=controller.end("drop");endReparent();clearPaint();activeTargetZone=null;host.emit({kind:"rowDragEnd",detail:{dragId:session.dragId,item,target,insertionIndex:suggested,keyboard:false,delegated,suggestedInsertionIndex:suggested,transfer:transfer.report,residue:ended.residue.slice(),reparent:reparented}});const label=host.rowLabel(item.data,item.startIndex);host.announce(dragAnnouncement({kind:"drop",label,from:item.startIndex+1,position:(suggested??item.startIndex)+1,total:host.displayRows().length}));controller=null;gesture=IDLE_GESTURE;pending=null},signal(cause){if(controller===null){gesture=IDLE_GESTURE;pending=null;return}const dragId=controller.session()?.dragId;const aborted=monitor.signal(cause,dragId===void 0?{}:{dragId});const reason=cause==="pointer-capture-lost"?"capture-lost":cause==="pointer-cancel"?"pointer-cancel":cause==="window-blur"||cause==="document-hidden"?"blur":"cancel";if(aborted.length>0||controller.session()?.phase==="ended"){const item=controller.session()?.item??null;endReparent();clearPaint();host.emit({kind:"rowDragCancel",detail:{dragId:dragId??"",item,reason,cause,residue:residue()}});controller=null;gesture=IDLE_GESTURE;pending=null;activeTargetZone=null}else{finish(reason,cause)}},escape(){if(controller===null){if(keyboard!==null)facade.cancelKeyboard();gesture=IDLE_GESTURE;pending=null;return}finish("escape","escape")},cancel(){if(controller===null){gesture=IDLE_GESTURE;pending=null;return}finish("cancel","cancel")},tick(){tickCounter+=1;const stuck=monitor.tick();if(stuck.length>0&&controller!==null){const item=controller.session()?.item??null;const dragId=controller.session()?.dragId??"";endReparent();clearPaint();host.emit({kind:"rowDragCancel",detail:{dragId,item,reason:"pointer-cancel",cause:"watchdog-timeout",residue:residue()}});controller=null;gesture=IDLE_GESTURE;pending=null;activeTargetZone=null;return}if(controller!==null&&host.reparent!==void 0){const live=controller.session();if(live!==null&&live.phase!=="ended")host.reparent.hoverTick(reparentHover,live.item.rowKeys)}},grab(rowIndex){if(disposed)return{status:"refused",reason:"disposed",detail:"the drag facade was disposed with its element"};if(controller!==null)return{status:"refused",reason:"already-dragging",detail:"a pointer drag session is live"};if(keyboard!==null)return{status:"refused",reason:"already-grabbed",detail:"a row is already grabbed"};const rows=host.displayRows();if(!Number.isInteger(rowIndex)||rowIndex<0||rowIndex>=rows.length){return{status:"refused",reason:"index-out-of-range",detail:`row ${rowIndex} is outside the ${rows.length} displayed rows`}}const reorder=createKeyboardReorder({rows,getRowKey:(row,index)=>host.rowKey(row,index),getRowLabel:(row,index)=>host.rowLabel(row,index)});const grabbed=reorder.grab(rowIndex);if(grabbed.outcome==="refused")return{status:"refused",reason:"index-out-of-range",detail:grabbed.detail};keyboard=reorder;keyboardOrigin=rowIndex;host.paintTarget(null,rowIndex);host.announce(grabbed.announcement);return{status:"grabbed",rowIndex,rowKey:host.rowKey(rows[rowIndex],rowIndex)}},key(command){if(keyboard===null)return{announcement:null,moved:false};const result=keyboard.move(command);if(result.announcement!==null)host.announce(result.announcement);if(result.outcome==="moved"){const state=keyboard.state();host.paintTarget({zoneId:ownZone,rowIndex:state.currentIndex,position:state.currentIndex>=keyboardOrigin?"below":"above"},keyboardOrigin);return{announcement:result.announcement,moved:true}}return{announcement:result.announcement,moved:false}},dropKeyboard(){if(keyboard===null)return;const state=keyboard.state();const dropped=keyboard.drop();keyboard=null;clearPaint();if(dropped.outcome==="refused")return;host.announce(dropped.announcement);const rows=host.displayRows();const row=rows[keyboardOrigin];const item={dragId:`keyboard-${tickCounter}-${keyboardOrigin}`,mode:"unmanaged",sourceZoneId:ownZone,rowKey:host.rowKey(row,keyboardOrigin),startIndex:keyboardOrigin,data:row,rowKeys:[host.rowKey(row,keyboardOrigin)],rows:[row]};const insertion=dropped.toIndex>dropped.fromIndex?dropped.toIndex+1:dropped.toIndex;host.emit({kind:"rowDragEnd",detail:{dragId:item.dragId,item,target:{zoneId:ownZone,rowIndex:dropped.toIndex,rowKey:null,position:dropped.toIndex>=dropped.fromIndex?"below":"above"},insertionIndex:insertion,keyboard:true,delegated:true,suggestedInsertionIndex:insertion,transfer:null,residue:[]}});void state;keyboardOrigin=-1},cancelKeyboard(){if(keyboard===null)return;const state=keyboard.state();keyboard.cancel();keyboard=null;clearPaint();const rows=host.displayRows();const row=rows[keyboardOrigin];host.announce(dragAnnouncement({kind:"cancel",label:row===void 0?"":host.rowLabel(row,keyboardOrigin),position:keyboardOrigin+1,total:rows.length}));host.emit({kind:"rowDragCancel",detail:{dragId:`keyboard-${tickCounter}-${keyboardOrigin}`,item:null,reason:"escape",cause:"keyboard",residue:[]}});void state;keyboardOrigin=-1},registerZone(input){const zone={id:input.id,kind:input.kind,accepting:input.accepting,rows:input.rows,getRowKey:input.getRowKey,schema:input.schema,permit:input.permit,adapt:input.adapt,consumes:input.consumes};const result=registry.add(zone);if(result.outcome==="added")zoneMeta.set(input.id,input);return result},unregisterZone(zoneId){if(zoneId===ownZone)return false;const removed=registry.remove(zoneId);zoneMeta.delete(zoneId);if(removed&&controller!==null&&activeTargetZone===zoneId){finish("cancel","cancel")}return removed},zones(){return{zones:registry.list().map(entry=>({id:entry.zone.id,kind:entry.zone.kind,accepting:entry.zone.accepting!==false,consumes:entry.zone.consumes===true,registeredAt:entry.registeredAt})),generation:registry.generation(),stats:registry.stats(),activeTargetZoneId:activeTargetZone,ownZoneId:ownZone}},session(){const live=controller!==null&&isPointerSession(controller)?controller:null;return{enabled:!disposed,gesture,session:live?.session()??null,report:live===null?null:rowDragReport(live),events:live?.events()??[],residue:residue(),keyboard:keyboard===null?null:{grabbed:true,originIndex:keyboardOrigin,currentIndex:keyboard.state().currentIndex},zones:registry.list().map(entry=>entry.zone.id),lastAutoScroll}},safety(){monitor.sweep();return dragSafetyReport(monitor,watchdogTicks)},dispose(){if(disposed)return;if(controller!==null){monitor.abortAll("element-disconnected");const item=controller.session()?.item??null;const dragId=controller.session()?.dragId??"";controller.end("cancel");endReparent();clearPaint();host.emit({kind:"rowDragCancel",detail:{dragId,item,reason:"cancel",cause:"element-disconnected",residue:[]}});controller=null}keyboard=null;disposed=true}};return facade}export function rowDragElementHost(element,glue){const zoneAtPoint=(x,y)=>{if(typeof document==="undefined")return null;const under=document.elementFromPoint(x,y);if(under===null)return null;for(const[zoneId,handle]of glue.zones()){if(handle.grid!==null&&handle.grid.contains(under)){const rowEl=under.closest(".sy-grid__row[data-row-index]");if(rowEl===null||!handle.grid.contains(rowEl)){return{zoneId,rowIndex:null,rowKey:null,position:"below"}}const rowIndex=Number(rowEl.getAttribute("data-row-index"));const rect=rowEl.getBoundingClientRect();const position=y<rect.top+rect.height/2?"above":"below";const rows=handle.grid.rowData??[];const row=rows[rowIndex];const getRowId=handle.grid.getRowId;const key=row===void 0?null:typeof getRowId==="function"?String(getRowId(row)):row.id===void 0?`index:${rowIndex}`:String(row.id);return{zoneId,rowIndex:Number.isInteger(rowIndex)?rowIndex:null,rowKey:key,position}}if(handle.element!==null&&handle.element.contains(under)){return{zoneId,rowIndex:null,rowKey:null,position:"below"}}}return null};return{zoneId:()=>glue.zoneId(),rows:()=>element.rowData??[],displayRows:()=>element.getDisplayRows(),rowKey:(row,index)=>glue.rowKey(row,index),rowLabel:(row,index)=>glue.rowLabel(row,index),rowIndexAtPoint:(x,y)=>element.rowIndexAtPoint(x,y),zoneAtPoint,window:()=>{const rows=element.getDisplayRows();const start=element.virtualWindow?.startIndex??0;const end=element.virtualWindow?.endIndex??rows.length;const keys=[];for(let index=start;index<Math.min(end,rows.length);index+=1)keys.push(glue.rowKey(rows[index],index));return{firstIndex:start,keys}},paintTarget:glue.paintTarget,reparent:glue.reparent,ghost:glue.ghost,announce:glue.announce,viewportScrollBox:()=>{const el=element.viewportEl;if(el===null)return null;const rect=el.getBoundingClientRect();return{id:"viewport",scrollLeft:el.scrollLeft,scrollTop:el.scrollTop,scrollWidth:el.scrollWidth,scrollHeight:el.scrollHeight,clientWidth:el.clientWidth,clientHeight:el.clientHeight,left:rect.left,top:rect.top,right:rect.right,bottom:rect.bottom}},scrollViewportBy:(dx,dy)=>{const el=element.viewportEl;if(el===null)return;if(dy!==0)el.scrollTop+=dy;if(dx!==0)el.scrollLeft+=dx},setRows:rows=>glue.setRows(rows),emit:glue.emit}}let zoneSeq=0;export function bindRowDragElement(element){zoneSeq+=1;let reparentFxInstance=null;const reparentFx=()=>{if(element.reparentHost===void 0||element.reparentFacadeFactory===void 0)return null;if(reparentFxInstance===null){const createReparentFacade=element.reparentFacadeFactory();if(createReparentFacade===null)return null;const view=element.reparentHost();if(view!==null)reparentFxInstance=createReparentFacade(view)}return reparentFxInstance};const zoneId=`grid:${element.host.id?element.host.id:`sy-grid-${zoneSeq}`}`;const zones=new Map;let ghostEl=null;let docCleanup=null;let tick=0;let tickHandle=null;const rowKey=(row,index)=>{const id=element.dragRowIdOf!==void 0?element.dragRowIdOf(row,index):element.extractRowId(row,index);return id===void 0?`index:${index}`:String(id)};const rowLabel=(row,index)=>{const cols=element.effectiveColumns();const first=cols.find(col=>col.rowDrag===true)??cols[0];const value=first===void 0?void 0:row[first.field];return value===void 0||value===null||value===""?rowKey(row,index):String(value)};const host=rowDragElementHost(element,{zoneId:()=>zoneId,rowKey,rowLabel,zones:()=>zones,paintTarget:(target,source)=>element.paintDragTarget(target,source),announce:announcement=>element.announceDrag(announcement),ghost:{create:(label,x,y)=>{if(typeof document==="undefined")return;ghostEl?.remove();const ghost=document.createElement("div");ghost.className="sy-grid__row-drag-ghost";ghost.setAttribute("aria-hidden","true");ghost.textContent=label;Object.assign(ghost.style,{position:"fixed",top:"0",left:"0",zIndex:"10000",pointerEvents:"none",padding:"4px 10px",borderRadius:"6px",whiteSpace:"nowrap",background:"var(--sy-grid-drag-ghost-bg, rgba(17, 24, 39, 0.88))",color:"var(--sy-grid-drag-ghost-color, #ffffff)",font:"13px/1.4 system-ui, sans-serif",boxShadow:"0 6px 18px rgba(0, 0, 0, 0.25)",transform:`translate(${x+12}px, ${y+12}px)`});document.body.appendChild(ghost);ghostEl=ghost},move:(x,y)=>{if(ghostEl!==null)ghostEl.style.transform=`translate(${x+12}px, ${y+12}px)`},destroy:()=>{ghostEl?.remove();ghostEl=null}},emit:event=>element.emitDrag(event),setRows:rows=>element.writeRows(rows),reparent:element.reparentHost===void 0?void 0:{probe:(rowIndex,_x,y,draggedKeys)=>{const fx=reparentFx();if(fx===null||!fx.active())return{intoTargetId:null,hoverNodeId:null};const nodeId=element.reparentNodeAt?.(rowIndex)??null;if(nodeId===null)return{intoTargetId:null,hoverNodeId:null};const ratio=element.rowBandRatio?.(rowIndex,y)??null;return{intoTargetId:ratio===null?null:fx.probe(nodeId,ratio,draggedKeys),hoverNodeId:nodeId}},hoverTick:(hoverNodeId,draggedKeys)=>{const fx=reparentFx();if(fx!==null&&fx.active())fx.hoverTick(hoverNodeId,draggedKeys)},drop:(targetNodeId,draggedKeys)=>{const fx=reparentFx();return fx!==null&&fx.dropInto(targetNodeId,draggedKeys).status==="applied"},end:()=>{reparentFxInstance?.endDrag()}}});const facade=createRowDragFacade(host,{multiRow:element.rowDragMultiRow===true,dragText:element.rowDragText,watchdogTicks:1800});const sample=event=>({pointerId:event.pointerId,pointerType:event.pointerType==="touch"||event.pointerType==="pen"?event.pointerType:"mouse",x:event.clientX,y:event.clientY,tick});const teardown=dispose=>{if(docCleanup!==null)docCleanup();ghostEl?.remove();ghostEl=null;if(dispose){facade.dispose();reparentFxInstance?.dispose();reparentFxInstance=null}};const install=()=>{if(docCleanup!==null||typeof document==="undefined")return;const onMove=e=>{facade.pointerMove(sample(e))};const onUp=e=>{teardown(false);facade.pointerUp(sample(e))};const onCancel=()=>{facade.signal("pointer-cancel");teardown(false)};const onKey=e=>{if(e.key==="Escape"){facade.escape();teardown(false)}};const onBlur=()=>{facade.signal("window-blur");teardown(false)};const onHidden=()=>{if(document.visibilityState==="hidden"){facade.signal("document-hidden");teardown(false)}};document.addEventListener("pointermove",onMove,true);document.addEventListener("pointerup",onUp,true);document.addEventListener("pointercancel",onCancel,true);document.addEventListener("keydown",onKey,true);window.addEventListener("blur",onBlur);document.addEventListener("visibilitychange",onHidden);const loop=()=>{tick+=1;facade.tick();tickHandle=requestAnimationFrame(loop)};tickHandle=requestAnimationFrame(loop);docCleanup=()=>{document.removeEventListener("pointermove",onMove,true);document.removeEventListener("pointerup",onUp,true);document.removeEventListener("pointercancel",onCancel,true);document.removeEventListener("keydown",onKey,true);window.removeEventListener("blur",onBlur);document.removeEventListener("visibilitychange",onHidden);if(tickHandle!==null)cancelAnimationFrame(tickHandle);tickHandle=null;docCleanup=null}};const KEYS={ArrowUp:"up",ArrowDown:"down",Home:"top",End:"bottom",PageUp:"page-up",PageDown:"page-down"};return{facade,zoneId,reparentFacade:()=>reparentFx(),pointerDown(rowIndex,event){const extra=[];if(element.rowDragMultiRow===true){const rows=element.getDisplayRows();const source=rows[rowIndex];const sourceId=source===void 0?void 0:element.extractRowId(source,rowIndex);if(sourceId!==void 0&&element.selectionState.selectedRowIds.has(sourceId)){rows.forEach((row,index)=>{const id=element.extractRowId(row,index);if(index!==rowIndex&&id!==void 0&&element.selectionState.selectedRowIds.has(id))extra.push(index)})}}install();facade.pointerDown({rowIndex,sample:sample(event),extraRowIndices:extra})},keyDown(rowIndex,event){const key=event.key;const grabbed=facade.session().keyboard!==null;if(key==="Escape"){if(grabbed)facade.cancelKeyboard();return grabbed}if(key===" "||key==="Enter"){if(grabbed)facade.dropKeyboard();else facade.grab(rowIndex);return true}const command=KEYS[key];if(command===void 0)return false;if(grabbed)facade.key(command);return grabbed},startFromApi(input){if(input?.mode==="pointer"){return{status:"refused",reason:"pointer-required",detail:'a pointer session starts from a real pointer-down on the row handle; use mode "keyboard" from the API'}}let rowIndex=typeof input?.rowIndex==="number"?input.rowIndex:-1;if(rowIndex<0&&input?.rowId!==void 0){rowIndex=element.getDisplayRows().findIndex((row,index)=>String(element.extractRowId(row,index))===String(input.rowId))}return facade.grab(rowIndex)},registerZone(input){const el=input.kind==="external"?typeof input.element==="string"?document.querySelector(input.element):input.element??null:null;const grid=input.kind==="grid"?input.grid??null:null;if(input.kind==="external"&&el===null){return{outcome:"refused",zoneId:input.id,reason:"element-missing",detail:"an external zone needs an element (or a selector that resolves)"}}if(input.kind==="grid"&&grid===null){return{outcome:"refused",zoneId:input.id,reason:"grid-missing",detail:"a grid zone needs the peer <sy-grid> element"}}const result=facade.registerZone({...input,rows:grid!==null?()=>grid.rowData??[]:void 0,getRowKey:grid!==null?(row,index)=>{const fn=grid.getRowId;const id=typeof fn==="function"?fn(row):row.id;return id===void 0||id===null?`index:${index}`:String(id)}:void 0,applyTarget:grid!==null?rows=>{grid.rowData=rows}:void 0,revertTarget:grid!==null?rows=>{grid.rowData=rows}:void 0});if(result.outcome==="added")zones.set(input.id,{element:el,grid});return result},unregisterZone(id){const removed=facade.unregisterZone(id);if(removed)zones.delete(id);return removed},teardown}}

package/dist/collection/components/grid/core/row-drag/unmanaged-drag.js

@@ -0,0 +1 @@
+import{computeInsertionIndex,isNoopDrop,reorderRows,updateRowDragOver}from"./reorder.js";export const ROW_DRAG_MODES=Object.freeze(["managed","unmanaged"]);export const ROW_DRAG_EVENT_KINDS=Object.freeze(["start","move","enter","leave","end"]);export const ROW_DRAG_RESOURCES=Object.freeze(["ghost","drop-indicator","target-highlight","pointer-capture","auto-scroll"]);export const ROW_DRAG_END_REASONS=Object.freeze(["drop","escape","cancel","no-target","pointer-cancel","capture-lost","blur","source-removed","data-replaced","zone-removed","disconnect","dispose"]);export const ROW_DRAG_COMPLETING_REASON="drop";export const ROW_DROP_REFUSAL_REASONS=Object.freeze(["no-session","no-target","stale-target","same-position","source-removed","target-not-droppable","cross-zone","already-ended","unmanaged-owns-no-rows"]);export function rowWindowKeyAt(window,index){const offset=index-window.firstIndex;if(!Number.isInteger(offset)||offset<0||offset>=window.keys.length)return null;return window.keys[offset]}export const ROW_DRAG_PHASES=Object.freeze(["dragging","ended"]);export const ROW_DRAG_START_REFUSALS=Object.freeze(["already-dragging","disposed","invalid-index","invalid-key","index-out-of-range","invalid-zone"]);const EMPTY_RESOURCES=Object.freeze([]);function emptyEndCounts(){const counts={};for(const reason of ROW_DRAG_END_REASONS)counts[reason]=0;return counts}const dropRefused=resolution=>resolution.refusal!==null;export function createRowDragController(config){const declaredMode=config.mode;if(declaredMode!=="managed"&&declaredMode!=="unmanaged"){throw new TypeError(`row drag mode must be 'managed' or 'unmanaged', got ${String(declaredMode)}`)}if(config.mode==="unmanaged"){const loose=config;if(loose.rows!==void 0||loose.getRowKey!==void 0){throw new TypeError(`unmanaged row drag owns no rows: pass them to the application, not to the controller (${ROW_DROP_REFUSAL_REASONS[8]})`)}}const id=config.id??`row-drag-${config.mode}`;const droppable=new Set(config.droppableZoneIds??[]);let rows=config.mode==="managed"?config.rows.slice():[];const getRowKey=config.mode==="managed"?config.getRowKey:null;let session=null;let events=[];let resources=new Set;let disposed=false;let dragSeq=0;let starts=0;let startRefusals=0;let moves=0;let enters=0;let leaves=0;let drops=0;let dropRefusals=0;let ends=0;let doubleEnds=0;let staleTargets=0;let ghostDetaches=0;let windows=0;let residueLeaks=0;const endsByReason=emptyEndCounts();const emit=event=>{const live=session;const withSeq={...event,seq:live.seq};live.seq+=1;events.push(withSeq)};const acquire=resource=>{resources.add(resource)};const release=resource=>{resources.delete(resource)};const releaseAll=()=>{resources=new Set};const zoneAccepts=zoneId=>{if(session===null)return false;if(droppable.size===0)return zoneId===session.item.sourceZoneId;return droppable.has(zoneId)};const sourceIndexNow=()=>{if(session===null||getRowKey===null)return null;const key=session.item.rowKey;for(let index=0;index<rows.length;index+=1){if(getRowKey(rows[index],index)===key)return index}return null};const clearTarget=stale=>{if(session===null||session.target===null)return;const target=session.target;session.target=null;session.reorderState=session.reorderState===null?null:updateRowDragOver(session.reorderState,null,target.position);release("drop-indicator");release("target-highlight");leaves+=1;if(stale)staleTargets+=1;emit({kind:"leave",dragId:session.dragId,mode:session.item.mode,item:session.item,target,stale})};const terminate=reason=>{if(session===null||session.phase==="ended"){doubleEnds+=1;if(resources.size>0)residueLeaks+=1;return{ended:false,reason:session?.endReason??null,alreadyEnded:true,residue:[...resources]}}const live=session;clearTarget(false);live.phase="ended";live.endReason=reason;live.ghostAnchored=false;ends+=1;endsByReason[reason]+=1;emit({kind:"end",dragId:live.dragId,mode:live.item.mode,item:live.item,reason,completed:reason===ROW_DRAG_COMPLETING_REASON});releaseAll();if(resources.size>0)residueLeaks+=1;return{ended:true,reason,alreadyEnded:false,residue:[...resources]}};const view=()=>{if(session===null)return null;return{dragId:session.dragId,mode:session.item.mode,phase:session.phase,item:session.item,target:session.target,ghostAnchored:session.ghostAnchored,endReason:session.endReason,reorderState:session.reorderState}};const liveSession=()=>session!==null&&session.phase==="dragging"?session:null;const insertionFor=target=>{if(target===null||target.rowIndex===null)return null;return computeInsertionIndex(target.rowIndex,target.position)};const common={id,mode:config.mode,start(request){if(disposed){startRefusals+=1;return{outcome:"refused",reason:"disposed",detail:"the controller was disposed"}}if(liveSession()!==null){startRefusals+=1;return{outcome:"refused",reason:"already-dragging",detail:"a drag session is live; end it before starting another"}}if(typeof request.zoneId!=="string"||request.zoneId===""){startRefusals+=1;return{outcome:"refused",reason:"invalid-zone",detail:"zoneId must be a non-empty string"}}if(typeof request.rowKey!=="string"||request.rowKey===""){startRefusals+=1;return{outcome:"refused",reason:"invalid-key",detail:"rowKey must be a non-empty string; a drag with no identity cannot survive a recycle"}}if(!Number.isInteger(request.rowIndex)||request.rowIndex<0){startRefusals+=1;return{outcome:"refused",reason:"invalid-index",detail:"rowIndex must be a non-negative integer"}}if(config.mode==="managed"&&request.rowIndex>=rows.length){startRefusals+=1;return{outcome:"refused",reason:"index-out-of-range",detail:`rowIndex ${request.rowIndex} is outside the ${rows.length}-row array`}}const keys=[request.rowKey];const data=[request.data];const seen=new Set([request.rowKey]);const extraKeys=request.extraKeys??[];const extraRows=request.extraRows??[];for(let i=0;i<extraKeys.length;i+=1){const key=extraKeys[i];if(typeof key!=="string"||key===""||seen.has(key))continue;seen.add(key);keys.push(key);if(i<extraRows.length)data.push(extraRows[i])}dragSeq+=1;const item=Object.freeze({dragId:`${id}#${dragSeq}`,mode:config.mode,sourceZoneId:request.zoneId,rowKey:request.rowKey,startIndex:request.rowIndex,data:request.data,rowKeys:Object.freeze(keys),rows:Object.freeze(data)});events=[];resources=new Set;session={dragId:item.dragId,phase:"dragging",item,target:null,ghostAnchored:true,endReason:null,reorderState:config.mode==="managed"?{sourceIndex:request.rowIndex,overIndex:null,position:"below"}:null,seq:0};acquire("ghost");acquire("pointer-capture");starts+=1;emit({kind:"start",dragId:item.dragId,mode:item.mode,item});return{outcome:"started",item}},moveOver(zoneId,rowIndex,position,rowKey=null){const live=liveSession();if(live===null){return{outcome:"refused",reason:session===null?"no-session":"ended",detail:"there is no live drag session"}}const next={zoneId,rowIndex:Number.isInteger(rowIndex)&&rowIndex>=0?rowIndex:null,rowKey:typeof rowKey==="string"&&rowKey!==""?rowKey:null,position};const previous=live.target;const changedZone=previous===null||previous.zoneId!==next.zoneId;if(changedZone&&previous!==null)clearTarget(false);const unchanged=previous!==null&&previous.zoneId===next.zoneId&&previous.rowIndex===next.rowIndex&&previous.rowKey===next.rowKey&&previous.position===next.position;if(unchanged)return{outcome:"unchanged",target:previous};live.target=next;if(live.reorderState!==null){live.reorderState=updateRowDragOver(live.reorderState,next.rowIndex,next.position)}acquire("drop-indicator");if(next.rowIndex!==null)acquire("target-highlight");else release("target-highlight");if(changedZone){enters+=1;emit({kind:"enter",dragId:live.dragId,mode:live.item.mode,item:live.item,target:next})}moves+=1;const insertionIndex=insertionFor(next);emit({kind:"move",dragId:live.dragId,mode:live.item.mode,item:live.item,target:next,insertionIndex});return{outcome:"moved",target:next,insertionIndex}},moveOut(){const live=liveSession();if(live===null){return{outcome:"refused",reason:session===null?"no-session":"ended",detail:"there is no live drag session"}}if(live.target===null)return{outcome:"unchanged",target:null};clearTarget(false);return{outcome:"left",target:null}},applyWindow(window){windows+=1;const live=liveSession();if(live===null){return{targetInvalidated:false,ghostAnchored:false,target:null}}const sourceVisible=window.keys.includes(live.item.rowKey);if(live.ghostAnchored&&!sourceVisible)ghostDetaches+=1;live.ghostAnchored=sourceVisible;let invalidated=false;const target=live.target;if(target!==null&&target.rowIndex!==null&&target.rowKey!==null){const keyNow=rowWindowKeyAt(window,target.rowIndex);if(keyNow!==target.rowKey){clearTarget(true);invalidated=true}}return{targetInvalidated:invalidated,ghostAnchored:live.ghostAnchored,target:live.target}},end(reason){return terminate(reason)},cancel(){return terminate("cancel")},escape(){return terminate("escape")},session:view,events:()=>events,residue:()=>resources.size===0?EMPTY_RESOURCES:[...resources],setAutoScrolling(active){if(liveSession()===null){release("auto-scroll");return}if(active)acquire("auto-scroll");else release("auto-scroll")},stats:()=>({starts,startRefusals,moves,enters,leaves,drops,dropRefusals,ends,doubleEnds,staleTargets,ghostDetaches,windows,residueLeaks,endsByReason:{...endsByReason}}),dispose(){const outcome=terminate("dispose");disposed=true;return outcome},disposed:false};const withLiveDisposedFlag=controller=>{Object.defineProperty(controller,"disposed",{get:()=>disposed,enumerable:true,configurable:false});return controller};const resolveDrop=()=>{const live=liveSession();if(live===null){return session===null?{refusal:"no-session",detail:"there is no drag session"}:{refusal:"already-ended",detail:`the session already ended (${String(session.endReason)})`}}const target=live.target;if(target===null){return{refusal:"no-target",detail:"the pointer is not over a drop target"}}if(!zoneAccepts(target.zoneId)){return target.zoneId===live.item.sourceZoneId?{refusal:"target-not-droppable",detail:`zone ${target.zoneId} does not accept drops`}:{refusal:"cross-zone",detail:`zone ${target.zoneId} is not the source zone ${live.item.sourceZoneId}; cross-zone transfers are Day 73 drop zones, not a reorder`}}if(target.rowIndex===null){return{refusal:"no-target",detail:"the pointer is inside the zone but over no row"}}return{refusal:null,target,session:live}};if(config.mode==="unmanaged"){const controller={...common,mode:"unmanaged",drop(){const resolved=resolveDrop();if(dropRefused(resolved)){dropRefusals+=1;return{outcome:"refused",reason:resolved.refusal,detail:resolved.detail}}const item=resolved.session.item;const target=resolved.target;const suggested=insertionFor(target);drops+=1;terminate("drop");return{outcome:"delegated",item,target,suggestedInsertionIndex:suggested}}};return withLiveDisposedFlag(controller)}const managed={...common,mode:"managed",rows:()=>rows,setRows(next){rows=next.slice();const live=liveSession();if(live===null)return;const index=sourceIndexNow();if(index===null){terminate("source-removed");return}live.reorderState={sourceIndex:index,overIndex:live.target?.rowIndex??null,position:live.target?.position??"below"}},drop(){const resolved=resolveDrop();if(dropRefused(resolved)){dropRefusals+=1;return{outcome:"refused",reason:resolved.refusal,detail:resolved.detail,rows}}const live=resolved.session;const target=resolved.target;const fromIndex=sourceIndexNow();if(fromIndex===null){dropRefusals+=1;const detail=`row ${live.item.rowKey} is no longer in the data`;terminate("source-removed");return{outcome:"refused",reason:"source-removed",detail,rows}}if(target.rowKey!==null){const targetIndex=target.rowIndex;const keyThere=targetIndex<rows.length&&getRowKey!==null?getRowKey(rows[targetIndex],targetIndex):null;if(keyThere!==target.rowKey){dropRefusals+=1;staleTargets+=1;const detail=`row ${target.rowKey} is no longer at display index ${targetIndex}`;terminate("cancel");return{outcome:"refused",reason:"stale-target",detail,rows}}}const insertionIndex=computeInsertionIndex(target.rowIndex,target.position);if(isNoopDrop(fromIndex,insertionIndex)){dropRefusals+=1;const detail=`inserting at ${insertionIndex} leaves row ${live.item.rowKey} where it is`;terminate("drop");return{outcome:"refused",reason:"same-position",detail,rows}}const next=reorderRows(rows,fromIndex,insertionIndex);const toIndex=insertionIndex>fromIndex?insertionIndex-1:insertionIndex;rows=next;const item=live.item;drops+=1;terminate("drop");return{outcome:"reordered",rows:next,fromIndex,toIndex,insertionIndex,item}}};return withLiveDisposedFlag(managed)}export function rowDragReport(controller){const live=controller.session();return{controllerId:controller.id,mode:controller.mode,phase:live?.phase??"none",dragId:live?.dragId??null,targetZoneId:live?.target?.zoneId??null,ghostAnchored:live?.ghostAnchored??false,residue:controller.residue(),ownsRows:controller.mode==="managed",eventKinds:controller.events().map(event=>event.kind),stats:controller.stats()}}export function validateRowDragEventOrder(events){const problems=[];if(events.length===0)return problems;if(events[0]?.kind!=="start")problems.push("the first event is not `start`");let starts=0;let ended=false;let inside=false;let expectedSeq=0;for(const event of events){if(event.seq!==expectedSeq){problems.push(`seq ${event.seq} out of order (expected ${expectedSeq})`)}expectedSeq=event.seq+1;if(ended)problems.push(`${event.kind} after end`);switch(event.kind){case"start":starts+=1;if(starts>1)problems.push("more than one `start`");break;case"enter":if(inside)problems.push("`enter` while already inside a zone");inside=true;break;case"leave":if(!inside)problems.push("`leave` without a matching `enter`");inside=false;break;case"move":if(!inside)problems.push("`move` outside every zone");break;case"end":if(inside)problems.push("`end` while still inside a zone (unbalanced enter/leave)");ended=true;break;default:problems.push(`unknown event kind ${String(event.kind)}`)}}if(starts===0)problems.push("no `start`");return problems}

package/dist/collection/components/grid/core/row-layout/aligned-grids-facade.js

@@ -0,0 +1 @@
+import{alignedGroupReport,createAlignedGridController}from"./aligned-grids.js";const groups=new Map;export function alignedGroupNames(){return[...groups.keys()]}function acquireGroup(group){const existing=groups.get(group);if(existing!==void 0)return existing;const entry={controller:createAlignedGridController({id:`group:${group}`}),members:new Set};groups.set(group,entry);return entry}function releaseGroup(group,memberId){const entry=groups.get(group);if(entry===void 0)return;entry.controller.leave(memberId);entry.members.delete(memberId);if(entry.members.size===0){entry.controller.dispose();groups.delete(group)}}export async function runSetAlignedGrids(facade,input,mintedGroup){const refuse=(reason,detail)=>({status:"refused",group:facade.group(),reason,detail,seeded:false,members:[],mismatches:[],peersConfigured:0});let group;let peers=[];if(input===null||input===void 0){group=null}else if(Array.isArray(input)){const elements=input.filter(peer=>typeof HTMLElement!=="undefined"&&peer instanceof HTMLElement);if(elements.length===0)return refuse("no-peers","an element-array input needs at least one peer <sy-grid> element");const nonGrid=elements.find(peer=>peer.tagName.toLowerCase()!=="sy-grid");if(nonGrid!==void 0)return refuse("not-a-grid",`aligned peers must be <sy-grid> elements; got <${nonGrid.tagName.toLowerCase()}>`);peers=elements;group=mintedGroup}else if(typeof input.group==="string"){group=input.group;if(group.length===0)return refuse("empty-group-name","the aligned group name must be a non-empty string")}else{return refuse("invalid-input","pass { group }, an array of peer <sy-grid> elements, or null")}if(group===null){facade.configure(null);return{status:"left",group:null,reason:null,detail:null,seeded:false,members:[],mismatches:[],peersConfigured:0}}const configured=facade.configure(group);let peersConfigured=0;for(const peer of peers){const method=peer.setAlignedGrids;if(typeof method!=="function")continue;const outcome=await method.call(peer,{group});if(outcome.status==="joined"||outcome.status==="unchanged")peersConfigured+=1}const report=facade.groupReport();return{status:configured.status==="unchanged"?"unchanged":"joined",group,reason:null,detail:null,seeded:configured.join?.seeded??false,members:report.report?.members??[],mismatches:report.mismatches,peersConfigured}}export function createAlignedGridsFacade(host){let current=null;let disposed=false;let lastSeen=null;let flushQueued=false;const member=()=>({id:host.memberId(),state:()=>host.snapshot(),apply:projection=>{host.apply(projection);lastSeen=host.snapshot()}});const controller=()=>current===null?null:groups.get(current)?.controller??null;const leave=()=>{if(current===null)return;releaseGroup(current,host.memberId());current=null;lastSeen=null};const reportChange=change=>{const live=controller();if(live===null)return{configured:false};return{configured:true,...live.report(host.memberId(),change)}};const flush=()=>{flushQueued=false;if(disposed||controller()===null)return;const next=host.snapshot();const previous=lastSeen;lastSeen=next;if(previous===null)return;const before=new Map(previous.columns.map(column=>[column.colId,column]));let orderMoved=next.columns.length!==previous.columns.length;for(let i=0;i<next.columns.length&&!orderMoved;i+=1){if(next.columns[i].colId!==previous.columns[i].colId)orderMoved=true}if(orderMoved)reportChange({kind:"order",order:next.columns.map(column=>column.colId)});for(const column of next.columns){const was=before.get(column.colId);if(was===void 0)continue;if(was.width!==column.width)reportChange({kind:"width",colId:column.colId,width:column.width});if(was.visible!==column.visible)reportChange({kind:"visibility",colId:column.colId,visible:column.visible});if(was.pinned!==column.pinned)reportChange({kind:"pin",colId:column.colId,pinned:column.pinned})}if(next.scrollLeft!==previous.scrollLeft)reportChange({kind:"scroll",scrollLeft:next.scrollLeft})};return{group:()=>current,configure(group){if(disposed||group===current)return{status:"unchanged",group:current,join:null};leave();if(group===null)return{status:"left",group:null,join:null};const entry=acquireGroup(group);const join=entry.controller.join(member());entry.members.add(host.memberId());current=group;lastSeen=host.snapshot();return{status:"joined",group,join}},report(change){return reportChange(change)},notify(){if(disposed||current===null||flushQueued)return;flushQueued=true;queueMicrotask(flush)},resync(){const live=controller();if(live===null)return{configured:false};const snapshot=host.snapshot();lastSeen=snapshot;const order=snapshot.columns.map(column=>column.colId);return{configured:true,...live.report(host.memberId(),{kind:"order",order})}},groupReport(){const live=controller();if(live===null){return{configured:false,group:null,memberId:host.memberId(),report:null,canonical:null,mismatches:[]}}return{configured:true,group:current,memberId:host.memberId(),report:alignedGroupReport(live),canonical:live.state(),mismatches:live.mismatches()}},publicReport(){const live=controller();if(live===null){return{configured:false,group:null,memberId:host.memberId(),members:[],generation:0,alignedColumns:[],canonical:null,mismatches:[],stats:null}}const report=alignedGroupReport(live);const{members:_members,generation:_generation,disposed:_disposed,...stats}=report.stats;return{configured:true,group:current,memberId:host.memberId(),members:report.members,generation:report.generation,alignedColumns:report.alignedColumns,canonical:live.state(),mismatches:live.mismatches(),stats}},dispose(){leave();disposed=true}}}

package/dist/collection/components/grid/core/row-layout/aligned-grids.js

@@ -0,0 +1 @@
+export const EMPTY_ALIGNED_STATE=Object.freeze({columns:Object.freeze([]),scrollLeft:0});export const ALIGNED_CHANGE_KINDS=Object.freeze(["width","visibility","pin","order","scroll"]);export const ALIGNED_MISMATCH_REASONS=Object.freeze(["absent-locally","extra-locally","disjoint","duplicate-column","unknown-column"]);export function alignedTokenKey(token){return`${token.origin}#${token.seq}`}export function projectAlignedOrder(memberOrder,canonicalOrder){const canonicalRank=new Map;for(let i=0;i<canonicalOrder.length;i+=1){const id=canonicalOrder[i];if(!canonicalRank.has(id))canonicalRank.set(id,canonicalRank.size)}const shared=[];const extras=[];const seen=new Set;let anchor=0;for(const colId of memberOrder){if(seen.has(colId))continue;seen.add(colId);if(canonicalRank.has(colId)){shared.push(colId);anchor+=1}else{extras.push({colId,anchor})}}if(shared.length===0){return[...seen]}shared.sort((a,b)=>canonicalRank.get(a)-canonicalRank.get(b));const out=[];for(let slot=0;slot<=shared.length;slot+=1){for(const extra of extras){if(extra.anchor===slot)out.push(extra.colId)}if(slot<shared.length)out.push(shared[slot])}return out}const isFiniteNumber=value=>typeof value==="number"&&Number.isFinite(value);const isColId=value=>typeof value==="string"&&value.length>0;function isValidChange(change){if(change===null||change===void 0)return false;switch(change.kind){case"width":return isColId(change.colId)&&isFiniteNumber(change.width)&&change.width>=0;case"visibility":return isColId(change.colId)&&typeof change.visible==="boolean";case"pin":return isColId(change.colId)&&(change.pinned===null||change.pinned==="left"||change.pinned==="right");case"order":return Array.isArray(change.order)&&change.order.every(isColId);case"scroll":return isFiniteNumber(change.scrollLeft);default:return false}}const columnsEqual=(a,b)=>a.colId===b.colId&&a.width===b.width&&a.visible===b.visible&&a.pinned===b.pinned;export function alignedStatesEqual(a,b,scrollTolerance=0){if(a.columns.length!==b.columns.length)return false;for(let i=0;i<a.columns.length;i+=1){if(!columnsEqual(a.columns[i],b.columns[i]))return false}return Math.abs(a.scrollLeft-b.scrollLeft)<=scrollTolerance}export const ALIGNED_OUTCOMES=Object.freeze(["accepted","echo","no-op","queued","unknown-member","unknown-column","invalid","drain-overflow","disposed"]);export const DEFAULT_ALIGNED_MAX_DRAIN_STEPS=64;export const DEFAULT_ALIGNED_MAX_SEEN_TOKENS=1024;export const DEFAULT_ALIGNED_SCROLL_TOLERANCE=.5;let controllerSequence=0;export function createAlignedGridController(options={}){controllerSequence+=1;const id=options.id??`aligned-${controllerSequence}`;const scrollTolerance=isFiniteNumber(options.scrollTolerance)&&options.scrollTolerance>=0?options.scrollTolerance:DEFAULT_ALIGNED_SCROLL_TOLERANCE;const maxDrainSteps=Number.isInteger(options.maxDrainSteps)&&options.maxDrainSteps>0?options.maxDrainSteps:DEFAULT_ALIGNED_MAX_DRAIN_STEPS;const maxSeenTokens=Number.isInteger(options.maxSeenTokens)&&options.maxSeenTokens>0?options.maxSeenTokens:DEFAULT_ALIGNED_MAX_SEEN_TOKENS;const members=new Map;const seenTokens=new Set;let canonical=EMPTY_ALIGNED_STATE;let seeded=false;let generation=0;let tokenSeq=0;let accepted=0;let echoes=0;let noOps=0;let refused=0;let publishes=0;let queuedCount=0;let maxDrainDepth=0;let drainOverflows=0;let applyThrew=0;let disposed=false;let publishing=false;let draining=false;const pending=[];let lastMismatches=Object.freeze([]);const stats=()=>Object.freeze({members:members.size,generation,accepted,echoes,noOps,refused,publishes,queued:queuedCount,maxDrainDepth,drainOverflows,applyThrew,disposed});const rememberToken=token=>{const key=alignedTokenKey(token);if(seenTokens.has(key))seenTokens.delete(key);seenTokens.add(key);while(seenTokens.size>maxSeenTokens){const oldest=seenTokens.values().next();if(oldest.done===true)break;seenTokens.delete(oldest.value)}};const mintToken=()=>{tokenSeq+=1;return{origin:id,seq:tokenSeq}};const canonicalIndex=colId=>canonical.columns.findIndex(column=>column.colId===colId);const project=(member,originId,token)=>{const own=safeState(member);const mismatches=[];const byId=new Map;const duplicates=new Set;for(const column of own.columns){if(byId.has(column.colId)){if(!duplicates.has(column.colId)){duplicates.add(column.colId);mismatches.push({reason:"duplicate-column",memberId:member.id,colId:column.colId,detail:"the member lists this column more than once; only the first is aligned"})}continue}byId.set(column.colId,column)}const canonicalById=new Map;for(const column of canonical.columns)canonicalById.set(column.colId,column);let sharedCount=0;for(const colId of byId.keys())if(canonicalById.has(colId))sharedCount+=1;if(sharedCount===0&&byId.size>0&&canonicalById.size>0){mismatches.push({reason:"disjoint",memberId:member.id,colId:null,detail:"no column id is shared with the group, so nothing is synchronised and the member keeps its own widths, order, visibility and pinning"});return Object.freeze({memberId:member.id,columns:own.columns,scrollLeft:own.scrollLeft,generation,originId,token,mismatches:Object.freeze(mismatches)})}for(const colId of canonicalById.keys()){if(byId.has(colId))continue;mismatches.push({reason:"absent-locally",memberId:member.id,colId,detail:"the group aligns this column and the member does not have it; it is not invented here"})}const ordered=projectAlignedOrder([...byId.keys()],canonical.columns.map(c=>c.colId));const columns=[];for(const colId of ordered){const mine=byId.get(colId);const theirs=canonicalById.get(colId);if(theirs===void 0){mismatches.push({reason:"extra-locally",memberId:member.id,colId,detail:"the group does not align this column, so its width, visibility and pinning are left exactly as the member had them"});columns.push(mine);continue}columns.push({colId,width:theirs.width,visible:theirs.visible,pinned:theirs.pinned})}return Object.freeze({memberId:member.id,columns:Object.freeze(columns),scrollLeft:canonical.scrollLeft,generation,originId,token,mismatches:Object.freeze(mismatches)})};const safeState=member=>{try{const value=member.state();if(value===null||value===void 0||!Array.isArray(value.columns)){return EMPTY_ALIGNED_STATE}return value}catch(error){applyThrew+=1;options.onError?.(error,member.id);return EMPTY_ALIGNED_STATE}};const publish=(originId,token)=>{let calls=0;publishing=true;try{for(const memberId of[...members.keys()]){const member=members.get(memberId);if(member===void 0)continue;const projection=project(member,originId,token);lastMismatches=projection.mismatches;try{member.apply(projection)}catch(error){applyThrew+=1;options.onError?.(error,memberId)}calls+=1;publishes+=1}}finally{publishing=false}return calls};const applyToCanonical=change=>{switch(change.kind){case"scroll":{if(Math.abs(canonical.scrollLeft-change.scrollLeft)<=scrollTolerance)return null;return{columns:canonical.columns,scrollLeft:change.scrollLeft}}case"order":{const reordered=projectAlignedOrder(canonical.columns.map(column=>column.colId),change.order);const byId=new Map(canonical.columns.map(column=>[column.colId,column]));const columns=reordered.map(colId=>byId.get(colId));if(columns.length!==canonical.columns.length)return null;let same=true;for(let i=0;i<columns.length;i+=1){if(columns[i]?.colId!==canonical.columns[i]?.colId){same=false;break}}if(same)return null;return{columns,scrollLeft:canonical.scrollLeft}}default:{const index=canonicalIndex(change.colId);if(index===-1)return null;const current=canonical.columns[index];let updated;if(change.kind==="width"){if(current.width===change.width)return null;updated={...current,width:change.width}}else if(change.kind==="visibility"){if(current.visible===change.visible)return null;updated={...current,visible:change.visible}}else{if(current.pinned===change.pinned)return null;updated={...current,pinned:change.pinned}}const columns=canonical.columns.slice();columns[index]=updated;return{columns,scrollLeft:canonical.scrollLeft}}}};const acceptChange=(memberId,change,token)=>{const next=applyToCanonical(change);if(next===null){noOps+=1;rememberToken(token);return{outcome:"no-op",generation,token,publishes:0,mismatches:lastMismatches}}canonical=Object.freeze({columns:Object.freeze(next.columns),scrollLeft:next.scrollLeft});generation+=1;accepted+=1;rememberToken(token);const calls=publish(memberId,token);return{outcome:"accepted",generation,token,publishes:calls,mismatches:lastMismatches}};const drain=()=>{if(draining)return 0;draining=true;let calls=0;let steps=0;try{while(pending.length>0){if(pending.length>maxDrainDepth)maxDrainDepth=pending.length;steps+=1;if(steps>maxDrainSteps){drainOverflows+=1;refused+=pending.length;pending.length=0;break}const item=pending.shift();if(item===void 0)break;const before=publishes;if(item.kind==="publish"){publish(item.originId,item.token);calls+=publishes-before;continue}if(!members.has(item.memberId)){refused+=1;continue}if(seenTokens.has(alignedTokenKey(item.token))){echoes+=1;continue}acceptChange(item.memberId,item.change,item.token);calls+=publishes-before}}finally{draining=false}return calls};const enqueue=item=>{queuedCount+=1;pending.push(item);if(pending.length>maxDrainDepth)maxDrainDepth=pending.length;return{outcome:"queued",generation,token:item.token,publishes:0,mismatches:lastMismatches}};const isDisjointMember=memberId=>{const member=members.get(memberId);if(member===void 0)return false;if(canonical.columns.length===0)return false;const own=safeState(member);if(own.columns.length===0)return false;const canonicalIds=new Set(canonical.columns.map(column=>column.colId));return!own.columns.some(column=>canonicalIds.has(column.colId))};const refuse=outcome=>{refused+=1;return{outcome,generation,token:null,publishes:0,mismatches:lastMismatches}};return{id,join(member){if(disposed)return{accepted:false,seeded:false,mismatches:[],generation};if(member===null||member===void 0||!isColId(member.id)){refused+=1;return{accepted:false,seeded:false,mismatches:[],generation}}if(members.has(member.id)){refused+=1;return{accepted:false,seeded:false,mismatches:[],generation}}members.set(member.id,member);const own=safeState(member);if(!seeded){seeded=true;canonical=Object.freeze({columns:Object.freeze(own.columns.map(column=>({...column}))),scrollLeft:own.scrollLeft});generation+=1;return{accepted:true,seeded:true,mismatches:[],generation}}const token=mintToken();rememberToken(token);const projection=project(member,null,token);try{member.apply(projection)}catch(error){applyThrew+=1;options.onError?.(error,member.id)}publishes+=1;drain();return{accepted:true,seeded:false,mismatches:projection.mismatches,generation}},leave(memberId){const removed=members.delete(memberId);if(removed){for(let i=pending.length-1;i>=0;i-=1){const item=pending[i];if(item!==void 0&&item.kind==="change"&&item.memberId===memberId){pending.splice(i,1);refused+=1}}}return removed},report(memberId,change,token){if(disposed)return refuse("disposed");if(!members.has(memberId))return refuse("unknown-member");if(!isValidChange(change))return refuse("invalid");const supplied=token!==void 0&&isColId(token.origin)&&Number.isInteger(token.seq)?token:null;if(supplied!==null&&seenTokens.has(alignedTokenKey(supplied))){echoes+=1;return{outcome:"echo",generation,token:supplied,publishes:0,mismatches:lastMismatches}}if(isDisjointMember(memberId)){refused+=1;return{outcome:"unknown-column",generation,token:null,publishes:0,mismatches:Object.freeze([{reason:"disjoint",memberId,colId:null,detail:"the member shares no column id with the group, so its reports are refused for the same reason its columns are left alone"}])}}if(change.kind!=="order"&&change.kind!=="scroll"){const own=safeState(members.get(memberId));const hasLocally=own.columns.some(column=>column.colId===change.colId);if(!hasLocally||canonicalIndex(change.colId)===-1){refused+=1;return{outcome:"unknown-column",generation,token:null,publishes:0,mismatches:Object.freeze([{reason:"unknown-column",memberId,colId:change.colId,detail:hasLocally?"the group does not align this column, so the change is refused rather than applied to a set that does not contain it":"the reporting member does not have this column"}])}}}const effective=supplied??mintToken();if(publishing)return enqueue({kind:"change",memberId,change,token:effective});const result=acceptChange(memberId,change,effective);const drained=drain();return{...result,publishes:result.publishes+drained}},absorb(projection){if(disposed)return refuse("disposed");if(projection===null||projection===void 0)return refuse("invalid");const key=alignedTokenKey(projection.token);if(seenTokens.has(key)){echoes+=1;return{outcome:"echo",generation,token:projection.token,publishes:0,mismatches:lastMismatches}}if(!seeded){seeded=true;canonical=Object.freeze({columns:Object.freeze(projection.columns.map(column=>({...column}))),scrollLeft:projection.scrollLeft});generation+=1;rememberToken(projection.token);const calls2=publish(projection.originId,projection.token);return{outcome:"accepted",generation,token:projection.token,publishes:calls2+drain(),mismatches:lastMismatches}}const incoming=new Map(projection.columns.map(column=>[column.colId,column]));const columns=canonical.columns.map(column=>{const source=incoming.get(column.colId);return source===void 0?column:{colId:column.colId,width:source.width,visible:source.visible,pinned:source.pinned}});const ordered=projectAlignedOrder(columns.map(column=>column.colId),projection.columns.map(column=>column.colId));const byId=new Map(columns.map(column=>[column.colId,column]));const nextColumns=ordered.map(colId=>byId.get(colId));const next={columns:nextColumns,scrollLeft:Math.abs(canonical.scrollLeft-projection.scrollLeft)<=scrollTolerance?canonical.scrollLeft:projection.scrollLeft};rememberToken(projection.token);if(alignedStatesEqual(canonical,next,scrollTolerance)){noOps+=1;return{outcome:"no-op",generation,token:projection.token,publishes:0,mismatches:lastMismatches}}canonical=Object.freeze({columns:Object.freeze(next.columns),scrollLeft:next.scrollLeft});generation+=1;accepted+=1;if(publishing){enqueue({kind:"publish",originId:projection.originId,token:projection.token});return{outcome:"accepted",generation,token:projection.token,publishes:0,mismatches:lastMismatches}}const calls=publish(projection.originId,projection.token);return{outcome:"accepted",generation,token:projection.token,publishes:calls+drain(),mismatches:lastMismatches}},state(){return canonical},members(){return[...members.keys()]},mismatches(){const all=[];const token={origin:id,seq:0};for(const member of members.values()){for(const mismatch of project(member,null,token).mismatches)all.push(mismatch)}return all},dispose(){if(disposed)return;disposed=true;members.clear();pending.length=0;seenTokens.clear()},stats}}export function linkAlignedControllers(a,b){const aMemberId=`bridge:${b.id}`;const bMemberId=`bridge:${a.id}`;const bridge=(selfId,target)=>({id:selfId,state:()=>target.state(),apply:projection=>{target.absorb({...projection,memberId:selfId})}});a.join(bridge(aMemberId,b));b.join(bridge(bMemberId,a));return{aMemberId,bMemberId,unlink(){a.leave(aMemberId);b.leave(bMemberId)}}}export function alignedGroupReport(controller){const mismatches=controller.mismatches();const byReason={};const absent=new Set;for(const mismatch of mismatches){byReason[mismatch.reason]=(byReason[mismatch.reason]??0)+1;if(mismatch.reason==="absent-locally"&&mismatch.colId!==null)absent.add(mismatch.colId)}const state=controller.state();return{controllerId:controller.id,members:controller.members(),generation:state===EMPTY_ALIGNED_STATE?0:controller.stats().generation,columnCount:state.columns.length,scrollLeft:state.scrollLeft,alignedColumns:state.columns.map(column=>column.colId).filter(colId=>!absent.has(colId)),mismatchCount:mismatches.length,mismatchesByReason:Object.freeze(byReason),stats:controller.stats()}}

package/dist/collection/components/grid/core/row-layout/col-span.js

@@ -0,0 +1 @@
+export const COL_SPAN_CONTAINERS=Object.freeze(["left","middle","right"]);const CONTAINER_RANK=Object.freeze({left:0,middle:1,right:2});export function columnContainerRuns(columns,getContainer){const runs=[];const containerAt=index2=>getContainer===void 0?"middle":getContainer(columns[index2],index2);let index=0;while(index<columns.length){const container=containerAt(index);let end=index+1;while(end<columns.length&&containerAt(end)===container)end+=1;runs.push({container,startIndex:index,endIndex:end});index=end}return runs}export function colSpanContainerOrder(runs){let previous=-1;for(const run of runs){const rank=CONTAINER_RANK[run.container];if(rank===void 0||rank<=previous)return"disordered";previous=rank}return"canonical"}export const COL_SPAN_REJECTION_REASONS=Object.freeze(["invalid-span","callback-threw","non-deterministic","clamped-to-container","clamped-to-boundary","clamped-to-end"]);const EMPTY_SPANS=Object.freeze([]);const EMPTY_REJECTIONS=Object.freeze([]);const EMPTY_RUNS=Object.freeze([]);const isUsableSpan=value=>typeof value==="number"&&Number.isInteger(value)&&value>=1;export function resolveColSpanLayout(options){const{columns,row,rowIndex,colSpan,getContainer,getBoundaryKey,verifyDeterminism=false}=options;const columnCount=columns.length;if(columnCount===0){return{rowIndex,columnCount:0,spans:EMPTY_SPANS,rejected:EMPTY_REJECTIONS,runs:EMPTY_RUNS,containerOrder:"canonical",callbackCalls:0}}const runs=columnContainerRuns(columns,getContainer);const boundaryAt=index=>getBoundaryKey===void 0?null:getBoundaryKey(columns[index],index);const spans=[];const rejected=[];let callbackCalls=0;for(const run of runs){let index=run.startIndex;while(index<run.endIndex){const params={row,rowIndex,column:columns[index],colIndex:index,container:run.container};let requested=null;let threw=false;try{callbackCalls+=1;const answer=colSpan(params);requested=typeof answer==="number"?answer:null;if(verifyDeterminism){callbackCalls+=1;const again=colSpan(params);if(!Object.is(answer,again)){rejected.push({reason:"non-deterministic",colIndex:index,requested:typeof answer==="number"?answer:null,applied:1,detail:`colSpan at column ${index} answered ${String(answer)} then ${String(again)} for identical params; a span callback must be a pure function of its params`});index+=1;continue}}if(!isUsableSpan(answer)){rejected.push({reason:"invalid-span",colIndex:index,requested,applied:1,detail:`colSpan at column ${index} returned ${String(answer)}; a span must be an integer >= 1`});index+=1;continue}requested=answer}catch(error){threw=true;rejected.push({reason:"callback-threw",colIndex:index,requested:null,applied:1,detail:`colSpan at column ${index} threw (${error instanceof Error?error.message:String(error)}); the cell falls back to span 1`})}if(threw||requested===null){index+=1;continue}let end=index+requested;if(end>columnCount){rejected.push({reason:"clamped-to-end",colIndex:index,requested,applied:columnCount-index,detail:`colSpan at column ${index} asked for ${requested} columns but only ${columnCount-index} remain in the column list`});end=columnCount}if(end>run.endIndex){rejected.push({reason:"clamped-to-container",colIndex:index,requested,applied:run.endIndex-index,detail:`colSpan at column ${index} would have crossed the ${run.container} container boundary at column ${run.endIndex}; a pinned container is painted in its own coordinate space, so the span was cut to ${run.endIndex-index} column(s)`});end=run.endIndex}if(getBoundaryKey!==void 0){const key=boundaryAt(index);let boundary=end;for(let probe=index+1;probe<end;probe+=1){if(!Object.is(boundaryAt(probe),key)){boundary=probe;break}}if(boundary<end){rejected.push({reason:"clamped-to-boundary",colIndex:index,requested,applied:boundary-index,detail:`colSpan at column ${index} would have crossed the declared boundary at column ${boundary} (boundary ${JSON.stringify(key)}); it was cut to ${boundary-index} column(s)`});end=boundary}}if(end-index>1){spans.push({originIndex:index,span:end-index,endIndex:end,container:run.container})}index=end}}return{rowIndex,columnCount,spans,rejected:rejected.length===0?EMPTY_REJECTIONS:rejected,runs,containerOrder:colSpanContainerOrder(runs),callbackCalls}}function findSpanSlot(layout,colIndex){const spans=layout.spans;let lo=0;let hi=spans.length-1;while(lo<=hi){const mid=lo+hi>>>1;const entry=spans[mid];if(colIndex<entry.originIndex)hi=mid-1;else if(colIndex>=entry.endIndex)lo=mid+1;else return mid}return-1}export function colSpanContainerAt(layout,colIndex){if(!Number.isInteger(colIndex)||colIndex<0||colIndex>=layout.columnCount)return null;for(const run of layout.runs){if(colIndex>=run.startIndex&&colIndex<run.endIndex)return run.container}return null}export function colSpanEntryAt(layout,colIndex){if(!Number.isInteger(colIndex)||colIndex<0||colIndex>=layout.columnCount)return null;const slot=findSpanSlot(layout,colIndex);if(slot>=0)return layout.spans[slot];return{originIndex:colIndex,span:1,endIndex:colIndex+1,container:colSpanContainerAt(layout,colIndex)??"middle"}}export function colSpanOriginAt(layout,colIndex){return colSpanEntryAt(layout,colIndex)?.originIndex??-1}export function isColSpanCovered(layout,colIndex){const entry=colSpanEntryAt(layout,colIndex);return entry!==null&&entry.originIndex!==colIndex}export function colSpanOrigins(layout){const origins=[];let index=0;for(const entry of layout.spans){for(;index<entry.originIndex;index+=1)origins.push(index);origins.push(entry.originIndex);index=entry.endIndex}for(;index<layout.columnCount;index+=1)origins.push(index);return origins}export const COL_SPAN_INVALIDATION_REASONS=Object.freeze(["move","resize","hide","pin","data","manual"]);export function createColSpanCache(){return{entries:new Map,revision:1,hits:0,misses:0,invalidations:0,lastReason:null}}export function invalidateColSpans(cache,reason,rowKey){if(rowKey===void 0)cache.entries.clear();else cache.entries.delete(rowKey);cache.revision+=1;cache.invalidations+=1;cache.lastReason=reason}export function resolveCachedColSpanLayout(cache,rowKey,options){const cached=cache.entries.get(rowKey);if(cached!==void 0&&cached.row===options.row&&cached.columns===options.columns&&cached.revision===cache.revision){cache.hits+=1;return cached.layout}cache.misses+=1;const layout=resolveColSpanLayout(options);cache.entries.set(rowKey,{row:options.row,columns:options.columns,revision:cache.revision,layout});return layout}export function colSpanCacheStats(cache){return{revision:cache.revision,entries:cache.entries.size,hits:cache.hits,misses:cache.misses,invalidations:cache.invalidations,lastReason:cache.lastReason}}export function createUniformColSpanMetrics(columnWidth){if(!Number.isFinite(columnWidth)||columnWidth<=0){throw new RangeError(`[Syidax] createUniformColSpanMetrics: columnWidth must be a finite positive number, got ${columnWidth}.`)}return{offsetAt:index=>Math.max(0,index)*columnWidth}}export function createColumnWidthMetrics(widths,baseOffset=0){if(!Number.isFinite(baseOffset)||baseOffset<0){throw new RangeError(`[Syidax] createColumnWidthMetrics: baseOffset must be a finite number >= 0, got ${baseOffset}.`)}const offsets=new Array(widths.length+1);offsets[0]=baseOffset;for(let index=0;index<widths.length;index+=1){const width=widths[index];if(!Number.isFinite(width)||width<=0){throw new RangeError(`[Syidax] createColumnWidthMetrics: column ${index} has no concrete pixel width (got ${String(width)}). A flex-sized column cannot be measured; resolve it to a concrete width first.`)}offsets[index+1]=offsets[index]+width}return{offsetAt:index=>{const clamped=Math.max(0,Math.min(widths.length,Math.floor(index)));return offsets[clamped]}}}export function colSpanRenderRange(layout,window){const startIndex=Math.max(0,Math.min(layout.columnCount,Math.floor(window.startIndex)));const endIndex=Math.max(startIndex,Math.min(layout.columnCount,Math.floor(window.endIndex)));if(startIndex>=endIndex)return{startIndex,endIndex};const first=colSpanEntryAt(layout,startIndex);const last=colSpanEntryAt(layout,endIndex-1);return{startIndex:first===null?startIndex:first.originIndex,endIndex:last===null?endIndex:last.endIndex}}export function measureColSpanGeometry(layout,window,metrics){const range=colSpanRenderRange(layout,window);const visibleStart=Math.max(0,Math.min(layout.columnCount,Math.floor(window.startIndex)));const visibleEnd=Math.max(visibleStart,Math.min(layout.columnCount,Math.floor(window.endIndex)));const placements=[];let index=range.startIndex;while(index<range.endIndex){const entry=colSpanEntryAt(layout,index);if(entry===null)break;const left=metrics.offsetAt(entry.originIndex);placements.push({originIndex:entry.originIndex,span:entry.span,endIndex:entry.endIndex,container:entry.container,left,width:metrics.offsetAt(entry.endIndex)-left,startsBeforeWindow:entry.originIndex<visibleStart,endsAfterWindow:entry.endIndex>visibleEnd});index=entry.endIndex}return placements}const finite=(value,fallback=0)=>typeof value==="number"&&Number.isFinite(value)?value:fallback;export function colSpanViewportRect(layout,metrics,viewport,colIndex){const entry=colSpanEntryAt(layout,colIndex);if(entry===null)return null;const contentLeft=metrics.offsetAt(entry.originIndex);const width=metrics.offsetAt(entry.endIndex)-contentLeft;const scrollLeft=finite(viewport.scrollLeft);const viewportWidth=finite(viewport.viewportWidth);const inset=finite(viewport.rightInset);switch(entry.container){case"left":return{left:contentLeft,width};case"right":{const total=metrics.offsetAt(layout.columnCount);return{left:viewportWidth-inset-total+contentLeft,width}}default:return{left:contentLeft-scrollLeft,width}}}export function hitTestColSpan(layout,metrics,viewport,viewportX){if(typeof viewportX!=="number"||!Number.isFinite(viewportX))return null;if(layout.columnCount===0)return null;const hitAt=colIndex=>{const entry=colSpanEntryAt(layout,colIndex);if(entry===null)return null;const rect=colSpanViewportRect(layout,metrics,viewport,entry.originIndex);if(rect===null)return null;if(viewportX<rect.left||viewportX>=rect.left+rect.width)return null;let hitColumn=entry.originIndex;const originLeft=metrics.offsetAt(entry.originIndex);for(let column=entry.originIndex;column<entry.endIndex;column+=1){const columnLeft=rect.left+(metrics.offsetAt(column)-originLeft);const columnRight=rect.left+(metrics.offsetAt(column+1)-originLeft);if(viewportX>=columnLeft&&viewportX<columnRight){hitColumn=column;break}}return{colIndex:hitColumn,originIndex:entry.originIndex,span:entry.span,endIndex:entry.endIndex,container:entry.container,covered:hitColumn!==entry.originIndex,rect}};const probePinned=container=>{for(const run of layout.runs){if(run.container!==container)continue;let index=run.startIndex;while(index<run.endIndex){const entry=colSpanEntryAt(layout,index);if(entry===null)break;const hit=hitAt(entry.originIndex);if(hit!==null)return hit;index=entry.endIndex}}return null};const probeMiddle=()=>{const contentX=viewportX+finite(viewport.scrollLeft);const column=columnAtContentX(metrics,layout.columnCount,contentX);if(column<0)return null;if(colSpanContainerAt(layout,column)!=="middle")return null;return hitAt(column)};return probePinned("right")??probePinned("left")??probeMiddle()}export function columnAtContentX(metrics,columnCount,contentX){if(!Number.isInteger(columnCount)||columnCount<=0)return-1;if(typeof contentX!=="number"||!Number.isFinite(contentX))return-1;if(contentX<metrics.offsetAt(0)||contentX>=metrics.offsetAt(columnCount))return-1;let lo=0;let hi=columnCount-1;while(lo<=hi){const mid=lo+hi>>>1;if(contentX<metrics.offsetAt(mid))hi=mid-1;else if(contentX>=metrics.offsetAt(mid+1))lo=mid+1;else return mid}return-1}

package/dist/collection/components/grid/core/row-layout/full-width-facade.js

@@ -0,0 +1 @@
+import{createFullWidthLifecycle,fullWidthEntryAt,fullWidthLayoutReport,fullWidthRowHeights,fullWidthSectionKeys,navigateFullWidth,resolveFullWidthLayout}from"./full-width-rows.js";const guiOf=instance=>instance!==null&&typeof instance==="object"&&"gui"in instance?instance.gui:instance;function coreRenderer(renderer){if(renderer.mode==="embedded"){return{mode:"embedded",create:params=>renderer.create(params),refresh:renderer.refresh===void 0?void 0:(instance,params)=>renderer.refresh(instance,params),destroy:renderer.destroy===void 0?void 0:(instance,params)=>renderer.destroy(instance,params)}}return{mode:"full-width",create:params=>renderer.create(params),refresh:renderer.refresh===void 0?void 0:(instance,params)=>renderer.refresh(instance,params),destroy:renderer.destroy===void 0?void 0:(instance,params)=>renderer.destroy(instance,params)}}export function createFullWidthFacade(host){let cache=null;let disposed=false;const lifecycle=createFullWidthLifecycle({resolveRenderer:()=>{const renderer=host.renderer();return renderer===void 0?null:coreRenderer(renderer)},onError:(error,phase,key)=>host.onRendererError(error,phase,key)});const resolve=()=>{const rows=host.rows();const columns=host.columns();if(cache!==null&&cache.rows===rows&&cache.columns===columns)return cache.layout;const predicate=host.isFullWidth();const renderer=host.renderer();const declared=host.declaredHeight();const layout=resolveFullWidthLayout({rows,columns,getRowId:host.rowIdOf,isFullWidth:predicate===void 0?void 0:params=>predicate({row:params.row,index:params.index,builtInKind:params.builtInKind}),classify:host.classify,resolveRenderer:()=>renderer===void 0?null:coreRenderer(renderer),getContainer:host.containerOf,getHeight:declared===void 0?void 0:typeof declared==="number"?()=>declared:(row,index)=>declared(row,index),uniformHeight:host.uniformHeight()});cache={rows,columns,layout};return layout};const hostOwned=entry=>entry!==null&&entry.kind==="full-width"&&entry.rowKind==="custom";const windowLayout=(startIndex,endIndex)=>{const layout=resolve();const mounts=layout.mounts.filter(mount=>mount.rowKind==="custom"&&mount.rowIndex>=startIndex&&mount.rowIndex<endIndex);return{...layout,mounts}};return{layout:resolve,invalidate:()=>{cache=null},declared:()=>host.isFullWidth()!==void 0,entryAt:rowIndex=>{const entry=fullWidthEntryAt(resolve(),rowIndex);if(entry!==null&&entry.kind==="full-width"&&entry.rowKind!=="custom"){return{kind:"cells",rowIndex:entry.rowIndex,row:entry.row,rowId:entry.rowId}}return entry},isFullWidthRow:rowIndex=>hostOwned(fullWidthEntryAt(resolve(),rowIndex)),heightAt:(index,uniform)=>hostOwned(fullWidthEntryAt(resolve(),index))?fullWidthRowHeights(resolve(),uniform)(index):uniform,sectionKeyOf:rowIndex=>{const layout=resolve();const row=host.rows()[rowIndex];if(row===void 0)return null;return String(fullWidthSectionKeys(layout)(row,rowIndex))},reconcile:(startIndex,endIndex)=>{if(disposed)return{result:lifecycle.reconcile({...resolve(),mounts:[]}),mounts:[]};const layout=windowLayout(startIndex,endIndex);const result=lifecycle.reconcile(layout);const mounts=[];for(const key of lifecycle.mountedKeys()){const record=lifecycle.lookup(key);if(record===null)continue;mounts.push({key,rowIndex:record.rowIndex,rowId:record.rowId,container:record.container,gui:guiOf(record.instance)})}return{result,mounts}},guiFor:key=>{const record=lifecycle.lookup(key);return record===null?null:guiOf(record.instance)},navigate:(from,direction,memoColIndex)=>navigateFullWidth(resolve(),from,direction,memoColIndex),focusStop:(rowIndex,colIndex)=>{const layout=resolve();const entry=fullWidthEntryAt(layout,rowIndex);if(entry===null)return null;if(hostOwned(entry))return{rowIndex,colIndex:null,kind:"full-width"};const clamped=colIndex===null?0:Math.min(Math.max(colIndex,0),Math.max(0,layout.columnCount-1));return{rowIndex,colIndex:clamped,kind:"cell"}},report:()=>fullWidthLayoutReport(resolve()),refusals:()=>resolve().refusals,refusalSignature:()=>resolve().refusals.map(refusal=>`${refusal.rowIndex}:${refusal.reason}`).join("|"),dispose:()=>{disposed=true;lifecycle.dispose()}}}export function fullWidthSegmentsOf(entry){return entry.kind==="full-width"?entry.segments:[]}

package/dist/collection/components/grid/core/row-layout/full-width-rows.js

@@ -0,0 +1 @@
+import{columnContainerRuns}from"./col-span.js";export const FULL_WIDTH_ROW_KINDS=Object.freeze(["detail","group","group-footer","loading","custom"]);export const GRID_OWNED_FULL_WIDTH_KINDS=Object.freeze(["detail","group","group-footer","loading"]);export const FULL_WIDTH_MODES=Object.freeze(["full-width","embedded"]);export const FULL_WIDTH_OWNERSHIP=Object.freeze({"full-width":Object.freeze({mode:"full-width",rowElement:"grid",segmentElements:"grid",content:"renderer",instances:"one",crossesContainers:true,participatesInPinning:false}),embedded:Object.freeze({mode:"embedded",rowElement:"grid",segmentElements:"grid",content:"renderer",instances:"one-per-container",crossesContainers:false,participatesInPinning:true})});export const FULL_WIDTH_REFUSAL_REASONS=Object.freeze(["predicate-threw","non-deterministic","renderer-missing","renderer-threw","mode-mismatch","kind-conflict","invalid-row-id","duplicate-row-id","empty-container","invalid-height"]);export const FULL_WIDTH_HEIGHT_SOURCES=Object.freeze(["measured","declared","uniform"]);export const DEFAULT_FULL_WIDTH_HEIGHT_ENTRIES=512;const heightKey=rowId=>JSON.stringify([rowId]);const isUsableHeight=value=>typeof value==="number"&&Number.isFinite(value)&&value>0;export function createFullWidthHeightStore(options){const max=options?.maxEntries!==void 0&&Number.isInteger(options.maxEntries)&&options.maxEntries>0?options.maxEntries:DEFAULT_FULL_WIDTH_HEIGHT_ENTRIES;const entries=new Map;let evicted=0;return{record(rowId,px){if(!isUsableHeight(px))return false;const key=heightKey(rowId);if(entries.has(key))entries.delete(key);entries.set(key,px);while(entries.size>max){const oldest=entries.keys().next();if(oldest.done===true)break;entries.delete(oldest.value);evicted+=1}return true},heightOf(rowId){const key=heightKey(rowId);const value=entries.get(key);if(value===void 0)return null;entries.delete(key);entries.set(key,value);return value},forget(rowId){return entries.delete(heightKey(rowId))},size(){return entries.size},clear(){entries.clear()},evictions(){return evicted}}}const EMPTY_SEGMENTS=Object.freeze([]);const EMPTY_MOUNTS=Object.freeze([]);const EMPTY_REFUSALS=Object.freeze([]);const EMPTY_ROWS=Object.freeze([]);export function fullWidthMountKey(rowId,container){return`fw:${JSON.stringify([rowId,container])}`}const isUsableRowId=value=>typeof value==="string"&&value.length>0||typeof value==="number"&&Number.isFinite(value);export function resolveFullWidthLayout(options){const{rows,columns,getRowId,isFullWidth,classify,resolveRenderer,getContainer,getHeight,uniformHeight,measured,verifyDeterminism}=options;const rowCount=rows.length;const columnCount=columns.length;const runs=columnContainerRuns(columns,getContainer);const fallbackHeight=isUsableHeight(uniformHeight)?uniformHeight:1;const entries=[];const fullWidthRows=[];const mounts=[];const refusals=[];const seenIds=new Map;let predicateCalls=0;const refuse=(reason,rowIndex,rowId,requested,applied,detail)=>{refusals.push({reason,rowIndex,rowId,requested,applied,detail})};for(let index=0;index<rowCount;index+=1){const row=rows[index];let builtInKind=null;if(classify!==void 0){const answer=classify(row,index);builtInKind=answer!==null&&answer!==void 0&&FULL_WIDTH_ROW_KINDS.includes(answer)?answer:null}const params={row,index,builtInKind};let wants=builtInKind!==null;let predicateSaidYes=false;if(isFullWidth!==void 0){try{predicateCalls+=1;predicateSaidYes=isFullWidth(params)===true;if(verifyDeterminism===true){predicateCalls+=1;const again=isFullWidth(params)===true;if(again!==predicateSaidYes){refuse("non-deterministic",index,null,`${predicateSaidYes?"full-width":"cells"} then ${again?"full-width":"cells"}`,"cells","the predicate answered differently for identical params; a layout that depends on how many times it is asked cannot be cached");entries.push({kind:"cells",rowIndex:index,row,rowId:null});continue}}}catch(error){refuse("predicate-threw",index,null,"unknown","cells",`the full-width predicate threw: ${describeError(error)}`);entries.push({kind:"cells",rowIndex:index,row,rowId:null});continue}if(predicateSaidYes&&builtInKind!==null){refuse("kind-conflict",index,null,`custom over ${builtInKind}`,builtInKind,`the grid already owns a '${builtInKind}' row: it has a renderer, a height rule and a teardown path, and a second owner is how one row gets two lifecycles`)}wants=wants||predicateSaidYes}if(!wants){const plainId=getRowId(row,index);entries.push({kind:"cells",rowIndex:index,row,rowId:isUsableRowId(plainId)?plainId:null});continue}const rowKind=builtInKind??"custom";const rawId=getRowId(row,index);if(!isUsableRowId(rawId)){refuse("invalid-row-id",index,null,String(rawId),"cells","a full-width row needs a stable id: the renderer lifecycle is keyed by it, and an id that moves recreates the renderer on every sort");entries.push({kind:"cells",rowIndex:index,row,rowId:null});continue}const idKey=heightKey(rawId);const firstAt=seenIds.get(idKey);if(firstAt!==void 0){refuse("duplicate-row-id",index,rawId,String(rawId),"cells",`row ${index} has the same id as row ${firstAt}; two mounts would share one key and one instance, so the later row falls back to cells`);entries.push({kind:"cells",rowIndex:index,row,rowId:rawId});continue}let renderer;try{renderer=resolveRenderer(params)}catch(error){refuse("renderer-threw",index,rawId,"a renderer","cells",`resolveRenderer threw: ${describeError(error)}`);entries.push({kind:"cells",rowIndex:index,row,rowId:rawId});continue}if(renderer===null||renderer===void 0){refuse("renderer-missing",index,rawId,`a '${rowKind}' renderer`,"cells","a full-width row with no renderer is a blank stripe where a row used to be; the cells still carry every value, so cells is the safe answer");entries.push({kind:"cells",rowIndex:index,row,rowId:rawId});continue}const mode=renderer.mode;if(!FULL_WIDTH_MODES.includes(mode)){refuse("mode-mismatch",index,rawId,String(mode),"cells",`'${String(mode)}' is not a full-width mode; the type union already refuses this and the check is the backstop for a JavaScript caller`);entries.push({kind:"cells",rowIndex:index,row,rowId:rawId});continue}let height=fallbackHeight;let heightSource="uniform";if(getHeight!==void 0){const declared=getHeight(row,index);if(declared!==null&&declared!==void 0){if(isUsableHeight(declared)){height=declared;heightSource="declared"}else{refuse("invalid-height",index,rawId,String(declared),String(fallbackHeight),"a height must be a finite positive number; a zero or NaN height collapses the row and the virtual window offsets with it")}}}const measuredPx=measured?.heightOf(rawId)??null;if(measuredPx!==null){height=measuredPx;heightSource="measured"}let segments=EMPTY_SEGMENTS;if(columnCount===0){segments=Object.freeze([{container:mode==="embedded"?"middle":null,startCol:0,endCol:0,colSpan:0,mountKey:fullWidthMountKey(rawId,mode==="embedded"?"middle":null)}])}else if(mode==="full-width"){segments=Object.freeze([{container:null,startCol:0,endCol:columnCount,colSpan:columnCount,mountKey:fullWidthMountKey(rawId,null)}])}else{const built=[];for(const container of["left","middle","right"]){let start=-1;let end=-1;for(const run of runs){if(run.container!==container)continue;if(start===-1||run.startIndex<start)start=run.startIndex;if(run.endIndex>end)end=run.endIndex}if(start===-1){refuse("empty-container",index,rawId,`an embedded '${container}' segment`,"no segment",`there are no '${container}' columns in this window, so the segment would be a zero-width box with a live renderer inside it`);continue}built.push({container,startCol:start,endCol:end,colSpan:end-start,mountKey:fullWidthMountKey(rawId,container)})}segments=Object.freeze(built)}const distinctRuns=new Set;for(const run of runs)distinctRuns.add(run.container);const crossesContainers=mode==="full-width"&&distinctRuns.size>1;seenIds.set(idKey,index);fullWidthRows.push(index);for(const segment of segments){mounts.push({key:segment.mountKey,rowId:rawId,rowIndex:index,container:segment.container,rowKind,mode,startCol:segment.startCol,endCol:segment.endCol})}entries.push({kind:"full-width",rowIndex:index,row,rowId:rawId,rowKind,mode,segments,height,heightSource,crossesContainers})}return{rowCount,columnCount,entries,fullWidthRows:fullWidthRows.length===0?EMPTY_ROWS:fullWidthRows,mounts:mounts.length===0?EMPTY_MOUNTS:mounts,refusals:refusals.length===0?EMPTY_REFUSALS:refusals,containerRuns:runs,predicateCalls}}function describeError(error){if(error instanceof Error)return error.message;return String(error)}export function fullWidthEntryAt(layout,rowIndex){if(!Number.isInteger(rowIndex)||rowIndex<0||rowIndex>=layout.rowCount)return null;return layout.entries[rowIndex]??null}export function isFullWidthRowAt(layout,rowIndex){return fullWidthEntryAt(layout,rowIndex)?.kind==="full-width"}export function fullWidthSegmentAt(layout,rowIndex,colIndex){const entry=fullWidthEntryAt(layout,rowIndex);if(entry===null||entry.kind!=="full-width")return null;for(const segment of entry.segments){if(colIndex>=segment.startCol&&colIndex<segment.endCol)return segment}return null}export function fullWidthRowHeights(layout,uniform){const safeUniform=isUsableHeight(uniform)?uniform:1;return index=>{const entry=fullWidthEntryAt(layout,index);if(entry===null||entry.kind!=="full-width")return safeUniform;return entry.height}}export function fullWidthSpanWindows(layout){const windows=[];let start=-1;for(let index=0;index<layout.rowCount;index+=1){const isFull=isFullWidthRowAt(layout,index);if(isFull){if(start!==-1){windows.push({startRow:start,endRow:index});start=-1}continue}if(start===-1)start=index}if(start!==-1)windows.push({startRow:start,endRow:layout.rowCount});return windows}export function fullWidthSectionKeys(layout,base){return(row,index)=>{if(isFullWidthRowAt(layout,index))return`fw:${index}`;const inner=base===void 0?null:base(row,index);return`cells:${inner===null?"":String(inner)}`}}export const FULL_WIDTH_NAV_DIRECTIONS=Object.freeze(["up","down","left","right"]);export function fullWidthFocusStop(layout,rowIndex,colIndex){const entry=fullWidthEntryAt(layout,rowIndex);if(entry===null)return null;if(entry.kind==="full-width")return{rowIndex,colIndex:null,kind:"full-width"};if(layout.columnCount===0)return null;const clamped=colIndex===null?0:Math.min(Math.max(Math.trunc(colIndex),0),layout.columnCount-1);return{rowIndex,colIndex:clamped,kind:"cell"}}export function navigateFullWidth(layout,from,direction,memoColIndex){const columnCount=layout.columnCount;const memoSeed=memoColIndex!==void 0&&Number.isInteger(memoColIndex)?memoColIndex:from.colIndex;const memo=columnCount===0?0:Math.min(Math.max(memoSeed??0,0),columnCount-1);const stay=refusal=>({from,to:from,moved:false,memoColIndex:memo,refusal});if(layout.rowCount===0)return stay("empty-grid");if(direction==="left"||direction==="right"){if(from.kind==="full-width"){return stay("no-cells")}if(columnCount===0)return stay("no-cells");const current=from.colIndex??0;const next=direction==="left"?current-1:current+1;if(next<0||next>=columnCount)return stay("edge");return{from,to:{rowIndex:from.rowIndex,colIndex:next,kind:"cell"},moved:true,memoColIndex:next,refusal:null}}const nextRow=direction==="up"?from.rowIndex-1:from.rowIndex+1;if(nextRow<0||nextRow>=layout.rowCount)return stay("edge");const target=fullWidthEntryAt(layout,nextRow);if(target===null)return stay("edge");if(target.kind==="full-width"){return{from,to:{rowIndex:nextRow,colIndex:null,kind:"full-width"},moved:true,memoColIndex:memo,refusal:null}}if(columnCount===0)return stay("no-cells");return{from,to:{rowIndex:nextRow,colIndex:memo,kind:"cell"},moved:true,memoColIndex:memo,refusal:null}}export function reconcileFullWidthMounts(previousMounted,desired){const desiredKeys=new Set;const created=[];const retained=[];for(const mount of desired){if(desiredKeys.has(mount.key))continue;desiredKeys.add(mount.key);if(previousMounted.has(mount.key))retained.push(mount.key);else created.push(mount.key)}const destroyed=[];for(const key of previousMounted){if(!desiredKeys.has(key))destroyed.push(key)}const stable=created.length===0&&destroyed.length===0;return{created,destroyed,retained,mounted:stable?previousMounted:desiredKeys,stable}}export function createFullWidthLifecycle(options){const records=new Map;const generations=new Map;const owners=new WeakMap;const destroyedInstances=new WeakSet;let creates=0;let destroys=0;let refreshes=0;let recreates=0;let doubleDestroyRefused=0;let foreignDestroyRefused=0;let reentrantRefused=0;let createThrew=0;let destroyThrew=0;let disposed=false;let busy=false;const snapshot=()=>Object.freeze({creates,destroys,mounted:records.size,refreshes,recreates,doubleDestroyRefused,foreignDestroyRefused,reentrantRefused,createThrew,destroyThrew,disposed});const report=(error,phase,key)=>{if(options.onError===void 0)return;try{options.onError(error,phase,key)}catch{}};const paramsFor=(mount,row)=>({row,rowId:mount.rowId,rowIndex:mount.rowIndex,rowKind:mount.rowKind,startCol:mount.startCol,endCol:mount.endCol,mountKey:mount.key,container:mount.container});const destroyRecord=record=>{const instance=record.instance;const isObject=typeof instance==="object"&&instance!==null||typeof instance==="function";if(isObject){const owner=owners.get(instance);if(owner!==void 0&&owner!==record.key){foreignDestroyRefused+=1;records.delete(record.key);return}if(destroyedInstances.has(instance)){doubleDestroyRefused+=1;records.delete(record.key);return}destroyedInstances.add(instance)}records.delete(record.key);destroys+=1;const destroy=record.renderer.destroy;if(destroy===void 0)return;try{destroy(record.instance,record.params)}catch(error){destroyThrew+=1;report(error,"destroy",record.key)}};const createRecord=(mount,row)=>{let renderer;try{renderer=options.resolveRenderer(mount,row)}catch(error){createThrew+=1;report(error,"create",mount.key);return false}if(renderer===null||renderer===void 0){createThrew+=1;report(new Error(`no renderer for mount ${mount.key}`),"create",mount.key);return false}const params=paramsFor(mount,row);let instance;try{instance=renderer.create(params)}catch(error){createThrew+=1;report(error,"create",mount.key);return false}const generation=(generations.get(mount.key)??0)+1;generations.set(mount.key,generation);creates+=1;const asUnknown=instance;if(typeof asUnknown==="object"&&asUnknown!==null||typeof asUnknown==="function"){owners.set(asUnknown,mount.key)}records.set(mount.key,{key:mount.key,rowId:mount.rowId,container:mount.container,mode:mount.mode,rowKind:mount.rowKind,instance,generation,row,rowIndex:mount.rowIndex,params,renderer});return true};const EMPTY=Object.freeze([]);return{reconcile(layout){if(disposed||busy){if(busy)reentrantRefused+=1;return{created:EMPTY,destroyed:EMPTY,retained:EMPTY,recreated:EMPTY,failed:EMPTY,stable:true,stats:snapshot()}}busy=true;try{const rowOf=new Map;for(const entry of layout.entries){if(entry.kind!=="full-width")continue;for(const segment of entry.segments)rowOf.set(segment.mountKey,entry.row)}const mountOf=new Map;for(const mount of layout.mounts){if(!mountOf.has(mount.key))mountOf.set(mount.key,mount)}const previous=new Set(records.keys());const delta=reconcileFullWidthMounts(previous,layout.mounts);const created=[];const destroyed=[];const retained=[];const recreated=[];const failed=[];for(const key of delta.destroyed){const record=records.get(key);if(record===void 0)continue;destroyRecord(record);destroyed.push(key)}for(const key of delta.retained){const record=records.get(key);if(record===void 0)continue;const mount=mountOf.get(key);if(mount===void 0)continue;const row=rowOf.get(key);const nextParams=paramsFor(mount,row);const refresh=record.renderer.refresh;let kept=true;if(refresh!==void 0){try{kept=refresh(record.instance,nextParams)!==false}catch(error){report(error,"refresh",key);kept=false}}if(kept){refreshes+=1;record.params=nextParams;record.row=row;record.rowIndex=mount.rowIndex;retained.push(key);continue}destroyRecord(record);if(createRecord(mount,row)){recreates+=1;recreated.push(key)}else{failed.push(key)}}for(const key of delta.created){const mount=mountOf.get(key);if(mount===void 0)continue;const row=rowOf.get(key);if(createRecord(mount,row))created.push(key);else failed.push(key)}return{created,destroyed,retained,recreated,failed,stable:created.length===0&&destroyed.length===0&&recreated.length===0,stats:snapshot()}}finally{busy=false}},lookup(key){const record=records.get(key);if(record===void 0)return null;return Object.freeze({key:record.key,rowId:record.rowId,container:record.container,mode:record.mode,rowKind:record.rowKind,instance:record.instance,generation:record.generation,row:record.row,rowIndex:record.rowIndex})},mountedKeys(){return[...records.keys()]},destroyAll(){if(busy){reentrantRefused+=1;return}busy=true;try{for(const record of[...records.values()])destroyRecord(record);records.clear()}finally{busy=false}},dispose(){if(disposed)return;if(busy){reentrantRefused+=1;return}busy=true;try{for(const record of[...records.values()])destroyRecord(record);records.clear();generations.clear()}finally{busy=false;disposed=true}},stats(){return snapshot()}}}export function fullWidthLayoutReport(layout){const byKind={detail:0,group:0,"group-footer":0,loading:0,custom:0};const byMode={"full-width":0,embedded:0};const byHeightSource={measured:0,declared:0,uniform:0};let fullWidthCount=0;let crossingContainers=0;for(const entry of layout.entries){if(entry.kind!=="full-width")continue;fullWidthCount+=1;byKind[entry.rowKind]+=1;byMode[entry.mode]+=1;byHeightSource[entry.heightSource]+=1;if(entry.crossesContainers)crossingContainers+=1}const refusalsByReason={};for(const refusal of layout.refusals){refusalsByReason[refusal.reason]=(refusalsByReason[refusal.reason]??0)+1}return{rowCount:layout.rowCount,columnCount:layout.columnCount,cellRowCount:layout.rowCount-fullWidthCount,fullWidthCount,mountCount:layout.mounts.length,byKind:Object.freeze(byKind),byMode:Object.freeze(byMode),byHeightSource:Object.freeze(byHeightSource),crossingContainers,spanWindowCount:fullWidthSpanWindows(layout).length,containerRunCount:layout.containerRuns.length,refusalCount:layout.refusals.length,refusalsByReason:Object.freeze(refusalsByReason)}}

package/dist/collection/components/grid/core/row-layout/pinned-row-policy.js

@@ -0,0 +1 @@
+import{findPinnedRow,resolvePinnedRows}from"./pinned-rows.js";export const PINNED_ROW_BANDS=Object.freeze(["top","center","bottom"]);const isCount=value=>typeof value==="number"&&Number.isInteger(value)&&value>=0;export function displayRowCount(model,centerRowCount){if(!isCount(centerRowCount))return model.top.length+model.bottom.length;return model.top.length+centerRowCount+model.bottom.length}export function addressDisplayRow(model,centerRowCount,displayIndex){if(!isCount(centerRowCount))return null;if(!Number.isInteger(displayIndex)||displayIndex<0)return null;const topCount=model.top.length;if(displayIndex<topCount){return{band:"top",displayIndex,centerIndex:null,row:model.top[displayIndex],sectionIndex:displayIndex}}const centerOffset=displayIndex-topCount;if(centerOffset<centerRowCount){return{band:"center",displayIndex,centerIndex:centerOffset,row:null,sectionIndex:null}}const bottomOffset=centerOffset-centerRowCount;if(bottomOffset<model.bottom.length){return{band:"bottom",displayIndex,centerIndex:null,row:model.bottom[bottomOffset],sectionIndex:bottomOffset}}return null}export function pinnedRowDisplayIndex(model,id,centerRowCount){const found=findPinnedRow(model,id);if(found===null||!isCount(centerRowCount))return-1;return found.section==="top"?found.index:model.top.length+centerRowCount+found.index}export function centerRowDisplayIndex(model,centerIndex){if(!Number.isInteger(centerIndex)||centerIndex<0)return-1;return model.top.length+centerIndex}export function isPinnedDisplayIndex(model,centerRowCount,displayIndex){const address=addressDisplayRow(model,centerRowCount,displayIndex);return address!==null&&address.band!=="center"}export const PINNED_ROW_FEATURES=Object.freeze(["row-selection","range-selection","cell-edit","row-edit","fill","clipboard-copy","clipboard-paste","export-csv","export-xlsx","export-pdf","formula-evaluate","formula-reference","rbac-read","rbac-write","keyboard-navigate"]);export const PINNED_ROW_POLICY_REASONS=Object.freeze(["own-data","identity-keyed","host-owned","band-aware","ambiguous-row-id","id-collision","display-index-addressed","no-source-row","not-in-source","pinned-boundary","no-sheet-anchor","would-shift-addresses","out-of-range"]);export const STRICT_PINNED_ROW_CONTEXT=Object.freeze({stableRowIds:false,idCollisions:0});export function pinnedRowIdCollisions(model,rows,getRowId){return resolvePinnedRows(model,rows,getRowId).resolved.map(entry=>entry.row.id)}const decide=(feature,support,reason,detail,options={})=>({feature,support,reason,detail,delegateKey:support==="delegated"?options.delegateKey??"pinned-address":null,mutating:options.mutating??false});export function pinnedRowPolicy(feature,context=STRICT_PINNED_ROW_CONTEXT){switch(feature){case"row-selection":{if(!context.stableRowIds){return decide(feature,"unsupported","ambiguous-row-id","row selection is id-keyed, but without a host getRowId the facade derives the id from the DISPLAY index — the exact number the pinned bands shift. Supply getRowId, or a pinned row and a data row will share an id.")}if(context.idCollisions>0){return decide(feature,"unsupported","id-collision",`${context.idCollisions} pinned id(s) also name a data row, so selecting that id no longer identifies one row. Unpin the duplicate or give the pinned row its own id.`)}return decide(feature,"delegated","identity-keyed","core/selection/row.ts addresses rows by stable id, so a pinned id selects the pinned row and nothing else. Pass the pinned id — never the display index — and keep it out of the visibleRowIds list that drives shift-range selection and the header checkbox.",{delegateKey:"row-id"})}case"range-selection":return decide(feature,"unsupported","display-index-addressed","canonical ranges store raw {row, col} display coordinates and clamp only against a row COUNT, so they cannot notice that the pinned-top band shifted every stored range. Select inside one band and decompose a cross-band rectangle with partitionDisplayRange.");case"cell-edit":return decide(feature,"unsupported","no-source-row","the commit path resolves a source row by object identity into rowData and writes back by that index. A pinned row is not in rowData, so today the write silently no-ops: the event fires, no data changes and no undo entry is recorded. Refuse it visibly instead.",{mutating:true});case"row-edit":return decide(feature,"unsupported","no-source-row","core/edit/row-edit.ts already classifies pinned-top/pinned-bottom rows as editable, so the SESSION opens — but the staged writes have no source row to land on (the same rowData lookup as cell-edit) and PE-ROWEDIT-01 leaves stageRowCell core-only. The session is not the write; refuse the write.",{mutating:true});case"fill":return decide(feature,"unsupported","pinned-boundary","core/selection/fill-handle.ts already declares a pinned row a FillRowBoundary and maps it to the 'pinned-boundary' exclusion, and fill-gestures stops the double-click scan there. Supply that boundary classifier from the address, so the exclusion is driven by the model rather than by a guess.",{mutating:true});case"clipboard-copy":return decide(feature,"supported","own-data","copy reads through a cellText(row, col) callback, so a pinned row copies its OWN data correctly as long as that callback is band-aware. Resolve the text through addressDisplayRow; a callback that indexes the pipeline output copies the wrong row.");case"clipboard-paste":return decide(feature,"unsupported","no-source-row","planPaste targets a display rectangle and the commit then drops any planned change whose row object is not in rowData — so a pinned target is planned, counted, and silently discarded. Clip the paste rectangle to the center band before planning.",{mutating:true});case"export-csv":case"export-xlsx":case"export-pdf":return decide(feature,"unsupported","not-in-source","the exporters enumerate a row array that is sourced from rowData, and none of them has a pinned/extra-row hook or a field mapping for rows with a different shape. Pinned rows are therefore ABSENT from every export today — report that to the caller rather than letting a total row quietly vanish from the file.");case"formula-evaluate":return decide(feature,"unsupported","no-sheet-anchor","GridFormulaSheet resolves a row to its A1 row number through a WeakMap keyed by the row object, seeded from rowData. A pinned row is not in it, so a formula on a pinned row falls back to a position-independent one-shot evaluation (relative references silently mean something else) and a calculated column renders the raw template.");case"formula-reference":return decide(feature,"unsupported","would-shift-addresses","seeding pinned rows into the sheet to make =A5 reach one would consume A1 row numbers and renumber every real row, changing the meaning of every existing formula in the workbook. A pinned row is not addressable from the sheet.");case"rbac-read":return decide(feature,"delegated","host-owned","canReadCell owns the answer. Hand it the COMPOSED display index from addressDisplayRow and the pinned row's own data — a policy that resolves rowIndex against the pipeline output reads a different row, and the masking path already passes a source-array index where the contract documents a display index.",{delegateKey:"pinned-address"});case"rbac-write":return decide(feature,"delegated","host-owned","canEditCell owns the permission answer, on the same band-aware address as rbac-read. It is an INDEPENDENT gate: an allow here does not make the write land, because cell-edit and row-edit are refused for want of a source row. Never treat an RBAC allow as a write path.",{delegateKey:"pinned-address"});case"keyboard-navigate":return decide(feature,"supported","band-aware","the focus model is a bare {rowIndex, colIndex} with no band concept, so this module supplies the rule: the composed viewport is ONE list, arrows cross top↔center↔bottom, and paging is center-relative. See navigatePinnedRows.");default:{const never=feature;throw new Error(`unknown pinned-row feature: ${JSON.stringify(never)}`)}}}export function pinnedRowPolicyMatrix(context=STRICT_PINNED_ROW_CONTEXT){return PINNED_ROW_FEATURES.map(feature=>pinnedRowPolicy(feature,context))}export function resolvePipelineRowIndex(model,centerRowCount,displayIndex){const address=addressDisplayRow(model,centerRowCount,displayIndex);if(address===null){return{ok:false,refusal:{feature:null,reason:"out-of-range",band:null,displayIndex,id:null,detail:`display index ${displayIndex} names no row in a viewport of ${displayRowCount(model,centerRowCount)} rows`}}}if(address.band==="center"){return{ok:true,centerIndex:address.centerIndex}}return{ok:false,refusal:{feature:null,reason:"display-index-addressed",band:address.band,displayIndex,id:address.row?.id??null,detail:`display index ${displayIndex} is the ${address.band}-pinned row ${JSON.stringify(address.row?.id)}; it has no pipeline position and must not be resolved as one`}}}export function planPinnedRowOperation(model,centerRowCount,feature,displayIndex,context=STRICT_PINNED_ROW_CONTEXT){const address=addressDisplayRow(model,centerRowCount,displayIndex);if(address===null){return{outcome:"refused",address:null,decision:null,refusal:{feature,reason:"out-of-range",band:null,displayIndex,id:null,detail:`display index ${displayIndex} names no row in a viewport of ${displayRowCount(model,centerRowCount)} rows`}}}if(address.band==="center"){return{outcome:"pipeline",address,centerIndex:address.centerIndex}}const decision=pinnedRowPolicy(feature,context);if(decision.support==="unsupported"){return{outcome:"refused",address,decision,refusal:{feature,reason:decision.reason,band:address.band,displayIndex,id:address.row?.id??null,detail:decision.detail}}}return{outcome:"pinned",address,decision}}export function partitionDisplayRange(model,centerRowCount,fromIndex,toIndex){const first=Math.min(fromIndex,toIndex);const last=Math.max(fromIndex,toIndex);const top=[];const bottom=[];const outOfRange=[];let centerStart=null;let centerEnd=0;for(let index=first;index<=last;index+=1){const address=addressDisplayRow(model,centerRowCount,index);if(address===null){outOfRange.push(index);continue}if(address.band==="top")top.push(address);else if(address.band==="bottom")bottom.push(address);else{const centerIndex=address.centerIndex;if(centerStart===null)centerStart=centerIndex;centerEnd=centerIndex+1}}const bandsTouched=(top.length>0?1:0)+(centerStart===null?0:1)+(bottom.length>0?1:0);return{top,center:centerStart===null?null:{startIndex:centerStart,endIndex:centerEnd},bottom,crossesBands:bandsTouched>1,outOfRange}}export const PINNED_ROW_NAV_DIRECTIONS=Object.freeze(["up","down","home","end","page-up","page-down"]);export function navigatePinnedRows(model,centerRowCount,displayIndex,direction,pageSize=1){const from=addressDisplayRow(model,centerRowCount,displayIndex);if(from===null)return null;const total=displayRowCount(model,centerRowCount);const step=Number.isInteger(pageSize)&&pageSize>0?pageSize:1;const topCount=model.top.length;const centerFirst=topCount;const centerLast=topCount+centerRowCount-1;let target;switch(direction){case"up":target=displayIndex-1;break;case"down":target=displayIndex+1;break;case"home":target=0;break;case"end":target=total-1;break;case"page-up":target=centerRowCount===0?displayIndex:from.band==="center"?Math.max(centerFirst,displayIndex-step):from.band==="bottom"?centerLast:displayIndex;break;case"page-down":target=centerRowCount===0?displayIndex:from.band==="center"?Math.min(centerLast,displayIndex+step):from.band==="top"?centerFirst:displayIndex;break;default:{const never=direction;throw new Error(`unknown navigation direction: ${JSON.stringify(never)}`)}}const clamped=Math.min(Math.max(0,target),Math.max(0,total-1));const to=addressDisplayRow(model,centerRowCount,clamped);if(to===null)return{from,to:from,moved:false,crossedBand:false};return{from,to,moved:to.displayIndex!==from.displayIndex,crossedBand:to.band!==from.band}}export function pinnedRowIntegrationReport(model,rows,getRowId,context=STRICT_PINNED_ROW_CONTEXT){const idCollisions=pinnedRowIdCollisions(model,rows,getRowId);const matrix=pinnedRowPolicyMatrix({...context,idCollisions:idCollisions.length});return{topCount:model.top.length,centerCount:rows.length,bottomCount:model.bottom.length,displayCount:displayRowCount(model,rows.length),idCollisions,unsupported:matrix.filter(entry=>entry.support==="unsupported"),delegated:matrix.filter(entry=>entry.support==="delegated"),supported:matrix.filter(entry=>entry.support==="supported")}}export const PINNED_ROW_SECTIONS=Object.freeze(["top","bottom"]);

package/dist/collection/components/grid/core/row-layout/pinned-rows-facade.js

@@ -0,0 +1 @@
+import{createPinnedRowModel,fromPinnedRowsSlice,replacePinnedRows,resolvePinnedRows,toPinnedRowsSlice}from"./pinned-rows.js";import{addressDisplayRow,displayRowCount,navigatePinnedRows,pinnedRowIntegrationReport,pinnedRowPolicy}from"./pinned-row-policy.js";const bandOf=address=>address.band;export function createPinnedRowsFacade(host){let model=createPinnedRowModel();let version=0;const context=()=>{const rowIdOf=host.rowIdOf;if(rowIdOf===null)return{stableRowIds:false,idCollisions:0};const collisions=resolvePinnedRows(model,host.sourceRows(),row=>rowIdOf(row)??"").resolved.length;return{stableRowIds:true,idCollisions:collisions}};const commit=result=>{const changed=result.model!==model&&result.changes.length>0;if(changed){model=result.model;version+=1}return{status:result.rejected.length>0&&!changed?"refused":changed?"applied":"unchanged",changes:result.changes,rejected:result.rejected,top:model.top.map(row=>row.id),bottom:model.bottom.map(row=>row.id)}};const centerCount=()=>host.displayRows().length;const composedIndex=(focus,centerRowIndex)=>{if(focus!==null){if(focus.band==="top")return focus.sectionIndex;return model.top.length+centerCount()+focus.sectionIndex}if(centerRowIndex===null||!Number.isInteger(centerRowIndex)||centerRowIndex<0)return null;return model.top.length+centerRowIndex};const toTarget=address=>{if(bandOf(address)==="center"){return{kind:"center",rowIndex:address.centerIndex??address.displayIndex-model.top.length}}const band=bandOf(address)==="top"?"top":"bottom";return{kind:"band",band,sectionIndex:address.sectionIndex??0}};return{model:()=>model,version:()=>version,rows:section=>model[section],count:()=>model.top.length+model.bottom.length,setPinned:input=>commit(replacePinnedRows(model,input)),address:displayIndex=>addressDisplayRow(model,centerCount(),displayIndex),composedIndex,navigate:(focus,centerRowIndex,direction,pageSize=1)=>{const from=composedIndex(focus,centerRowIndex);if(from===null)return null;const nav=navigatePinnedRows(model,centerCount(),from,direction,pageSize);if(nav===null)return null;return{target:toTarget(nav.to),moved:nav.moved,crossedBand:nav.crossedBand}},policy:feature=>pinnedRowPolicy(feature,context()),allows:feature=>pinnedRowPolicy(feature,context()).support!=="unsupported",report:()=>{const rowIdOf=host.rowIdOf;return pinnedRowIntegrationReport(model,host.displayRows(),rowIdOf===null?()=>"":row=>rowIdOf(row)??"",context())},toSlice:()=>toPinnedRowsSlice(model),restoreSlice:slice=>{const rowIdOf=host.rowIdOf;const byId=new Map;if(rowIdOf!==null){for(const row of host.sourceRows()){const id=rowIdOf(row);if(id!==void 0&&!byId.has(id))byId.set(id,row)}}const result=fromPinnedRowsSlice(slice,id=>byId.get(id));const dropped=result.rejected.filter(entry=>entry.reason==="unknown-id"&&entry.id!==null).map(entry=>entry.id);const outcome=commit({model:result.model,changes:result.changes,rejected:result.rejected});if(result.model!==model&&result.rejected.every(entry=>entry.reason==="unknown-id")){model=result.model;version+=1}return{...outcome,top:model.top.map(row=>row.id),bottom:model.bottom.map(row=>row.id),dropped}},dangling:()=>{const rowIdOf=host.rowIdOf;if(rowIdOf===null)return[...model.top,...model.bottom].map(row=>row.id);return resolvePinnedRows(model,host.sourceRows(),row=>rowIdOf(row)??"").dangling.map(entry=>entry.row.id)}}}export function pinnedDisplayRowCount(model,centerRowCount){return displayRowCount(model,centerRowCount)}export function paintPinnedBandCell(host,row,sectionIndex,column){const raw=host.rawValue(row,sectionIndex,column);const readable=host.readable(raw,row,sectionIndex,column);const masked=host.maskedRow(row,sectionIndex);const value=readable?host.value(masked,sectionIndex,column):host.maskedValue;const display=column.valueFormatter!==void 0&&column.valueFormatter!==null?host.format(value,masked,sectionIndex,column):value==null?"":String(value);const classText=host.classRules(value,typeof display==="string"?display:void 0,masked,sectionIndex,column);const classes={};if(classText.length>0){for(const cls of classText.split(" "))if(cls.length>0)classes[cls]=true}return{display,classes,style:host.styleRules(value,typeof display==="string"?display:void 0,masked,sectionIndex,column)}}

package/dist/collection/components/grid/core/row-layout/pinned-rows.js

@@ -0,0 +1 @@
+import{validatePinnedRowsSlice}from"../state/slices/ui.js";export const PINNED_ROW_CHANGE_KINDS=Object.freeze(["pinned","unpinned","moved","updated"]);const SECTIONS=Object.freeze(["top","bottom"]);const isRowId=value=>typeof value==="string"&&value.length>0||typeof value==="number"&&Number.isFinite(value);const describeId=value=>typeof value==="string"?JSON.stringify(value):String(value);const toDraft=model=>({top:[...model.top],bottom:[...model.bottom],nextSeq:model.nextSeq});const sealDraft=draft=>({top:draft.top,bottom:draft.bottom,nextSeq:draft.nextSeq});const locate=(draft,id)=>{for(const section of SECTIONS){const rows=draft[section];for(let index=0;index<rows.length;index+=1){const row=rows[index];if(row.id===id)return{row,section,index}}}return null};const resolveIndex=(requested,length)=>{if(requested===void 0||!Number.isFinite(requested))return length;return Math.min(Math.max(0,Math.floor(requested)),length)};const withPlacement=(row,section)=>row.section===section?row:{...row,section};const unchanged=(model,rejected=[])=>({model,changes:[],rejected});export function createPinnedRowModel(){return{top:[],bottom:[],nextSeq:1}}export function pinnedRowCount(model){return model.top.length+model.bottom.length}export function findPinnedRow(model,id){return locate(model,id)}export function pinnedRowRef(model,id){const found=locate(model,id);return found===null?null:{id:found.row.id,pinSeq:found.row.pinSeq}}export function isPinnedRowRefLive(model,ref){const found=locate(model,ref.id);return found!==null&&found.row.pinSeq===ref.pinSeq}export function layoutWithPinnedRows(model,displayRows){return{top:model.top,center:displayRows,bottom:model.bottom}}export function pinRow(model,entry,options={}){const section=options.section??"top";if(!isRowId(entry.id)){return unchanged(model,[{reason:"invalid-id",id:null,detail:`${describeId(entry.id)} is not a row id (non-empty string or finite number)`}])}const existing=locate(model,entry.id);if(existing!==null){return unchanged(model,[{reason:"already-pinned",id:entry.id,detail:`row ${describeId(entry.id)} is already pinned to ${existing.section} at index ${existing.index}; use movePinnedRow to relocate it`}])}const draft=toDraft(model);const seq=draft.nextSeq;const row={id:entry.id,section,pinSeq:seq,rev:seq+1,data:entry.data};draft.nextSeq=seq+2;const index=resolveIndex(options.index,draft[section].length);draft[section].splice(index,0,row);return{model:sealDraft(draft),changes:[{kind:"pinned",id:row.id,section,index,row}],rejected:[]}}export function unpinRow(model,id){const found=locate(model,id);if(found===null){return unchanged(model,[{reason:"unknown-id",id:isRowId(id)?id:null,detail:`row ${describeId(id)} is not pinned`}])}const draft=toDraft(model);draft[found.section].splice(found.index,1);return{model:sealDraft(draft),changes:[{kind:"unpinned",id:found.row.id,section:found.section,index:found.index,row:found.row}],rejected:[]}}export function movePinnedRow(model,id,target={}){const found=locate(model,id);if(found===null){return unchanged(model,[{reason:"unknown-id",id:isRowId(id)?id:null,detail:`row ${describeId(id)} is not pinned; nothing to move`}])}const section=target.section??found.section;const draft=toDraft(model);draft[found.section].splice(found.index,1);const index=resolveIndex(target.index,draft[section].length);if(section===found.section&&index===found.index){return unchanged(model)}const row=withPlacement(found.row,section);draft[section].splice(index,0,row);return{model:sealDraft(draft),changes:[{kind:"moved",id:row.id,from:{section:found.section,index:found.index},to:{section,index},row}],rejected:[]}}export function applyPinnedRowUpdates(model,updates){const rejected=[];const seen=new Set;const targets=[];for(const update of updates){if(!isRowId(update.id)){rejected.push({reason:"invalid-id",id:null,detail:`${describeId(update.id)} is not a row id`});continue}if(seen.has(update.id)){rejected.push({reason:"duplicate-id",id:update.id,detail:`row ${describeId(update.id)} appears more than once in one update transaction`});continue}seen.add(update.id);const found=locate(model,update.id);if(found===null){rejected.push({reason:"unknown-id",id:update.id,detail:`row ${describeId(update.id)} is not pinned`});continue}targets.push(found)}if(rejected.length>0)return unchanged(model,rejected);const draft=toDraft(model);const changes=[];for(let i=0;i<targets.length;i+=1){const target=targets[i];const update=updates[i];const previous=target.row;if(Object.is(previous.data,update.data))continue;const row={...previous,rev:draft.nextSeq,data:update.data};draft.nextSeq+=1;draft[target.section][target.index]=row;changes.push({kind:"updated",id:row.id,section:target.section,index:target.index,row,previous})}if(changes.length===0)return unchanged(model);return{model:sealDraft(draft),changes,rejected:[]}}export function replacePinnedRows(model,next){const requested=[];const rejected=[];const placement=new Map;for(const section of SECTIONS){for(const entry of next[section]??[]){if(!isRowId(entry.id)){rejected.push({reason:"invalid-id",id:null,detail:`${describeId(entry.id)} is not a row id`});continue}const already=placement.get(entry.id);if(already!==void 0){rejected.push({reason:already===section?"duplicate-id":"section-conflict",id:entry.id,detail:already===section?`row ${describeId(entry.id)} appears twice in the ${section} section`:`row ${describeId(entry.id)} is requested in both the top and bottom sections`});continue}placement.set(entry.id,section);requested.push({section,entry})}}if(rejected.length>0)return unchanged(model,rejected);const draft=toDraft(model);const changes=[];for(const section of SECTIONS){for(const row of[...draft[section]]){if(placement.has(row.id))continue;const index=draft[section].indexOf(row);draft[section].splice(index,1);changes.push({kind:"unpinned",id:row.id,section,index,row})}}for(const{section,entry}of requested){const index=countFinalized(requested,section,entry.id);const found=locate(draft,entry.id);if(found===null){const seq=draft.nextSeq;const row={id:entry.id,section,pinSeq:seq,rev:seq+1,data:entry.data};draft.nextSeq=seq+2;draft[section].splice(index,0,row);changes.push({kind:"pinned",id:row.id,section,index,row});continue}let current=found.row;if(found.section!==section||found.index!==index){draft[found.section].splice(found.index,1);current=withPlacement(current,section);draft[section].splice(index,0,current);changes.push({kind:"moved",id:current.id,from:{section:found.section,index:found.index},to:{section,index},row:current})}if(!Object.is(current.data,entry.data)){const previous=current;const row={...current,rev:draft.nextSeq,data:entry.data};draft.nextSeq+=1;draft[section][index]=row;changes.push({kind:"updated",id:row.id,section,index,row,previous})}}if(changes.length===0)return unchanged(model);return{model:sealDraft(draft),changes,rejected:[]}}function countFinalized(requested,section,id){let index=0;for(const candidate of requested){if(candidate.entry.id===id)break;if(candidate.section===section)index+=1}return index}export function resolvePinnedRows(model,rows,getRowId){const byId=new Map;for(const row of rows){const id=getRowId(row);if(!byId.has(id))byId.set(id,row)}const resolved=[];const dangling=[];for(const section of SECTIONS){const list=model[section];for(let index=0;index<list.length;index+=1){const row=list[index];const dataRow=byId.get(row.id);if(dataRow===void 0)dangling.push({row,section,index});else resolved.push({row,section,index,dataRow})}}return{resolved,dangling}}export function toPinnedRowsSlice(model){return{topRowIds:model.top.map(row=>row.id),bottomRowIds:model.bottom.map(row=>row.id)}}export function fromPinnedRowsSlice(slice,resolveData){const empty=createPinnedRowModel();const issues=validatePinnedRowsSlice(slice);if(issues.length>0){return unchanged(empty,issues.map(issue=>({reason:"invalid-slice",id:null,detail:`${issue.path}: ${issue.detail}`})))}const rejected=[];const changes=[];const draft=toDraft(empty);const placement=new Map;for(const section of SECTIONS){const ids=section==="top"?slice.topRowIds:slice.bottomRowIds;for(const id of ids){const already=placement.get(id);if(already!==void 0){rejected.push({reason:already===section?"duplicate-id":"section-conflict",id,detail:already===section?`row ${describeId(id)} appears twice in the restored ${section} section`:`row ${describeId(id)} is present in both restored sections`});continue}placement.set(id,section);const data=resolveData(id);if(data===void 0){rejected.push({reason:"unknown-id",id,detail:`row ${describeId(id)} has no data in this dataset; it was not restored`});continue}const seq=draft.nextSeq;const row={id,section,pinSeq:seq,rev:seq+1,data};draft.nextSeq=seq+2;const index=draft[section].length;draft[section].push(row);changes.push({kind:"pinned",id,section,index,row})}}return{model:sealDraft(draft),changes,rejected}}

package/dist/collection/components/grid/core/row-layout/row-layout-chunk.js

@@ -0,0 +1 @@
+export*from"./row-span.js";export*from"./col-span.js";export*from"./span-interaction.js";export*from"./row-layout-facade.js";export*from"./pinned-rows.js";export*from"./pinned-row-policy.js";export*from"./pinned-rows-facade.js";export*from"./full-width-rows.js";export*from"./full-width-facade.js";export*from"./aligned-grids.js";export*from"./aligned-grids-facade.js";

package/dist/collection/components/grid/core/row-layout/row-layout-facade.js

@@ -0,0 +1 @@
+import{createRowSpanCache,invalidateRowSpans,measureRowSpanGeometry,resolveCachedRowSpanLayout,rowSpanCacheStats,rowSpanEntryAt,rowSpanRenderRange}from"./row-span.js";import{resolveColSpanLayout}from"./col-span.js";import{expandSpanRange,navigateSpan,resolveSpanAccess,resolveSpanGrid,spanGridReport,spanRectAt,spanValueMatrix}from"./span-interaction.js";export const ROW_SPAN_MAX=100;export function createRowLayoutState(){return{rowSpanCache:createRowSpanCache(),clampedToMax:new Map,clampedRevision:0}}export function invalidateRowLayout(state,reason){invalidateRowSpans(state.rowSpanCache,reason);state.clampedToMax.clear()}const PLAIN=(rowIndex,colIndex)=>({kind:"plain",rowSpan:1,colSpan:1,origin:{rowIndex,colIndex},heightPx:null,widthPx:null,flexGrow:null,lastField:null});const EMPTY_CONFLICTS=Object.freeze([]);function inertFrame(status,window){return{status,configured:status!=="not-configured",window,renderRange:window,grid:null,conflicts:EMPTY_CONFLICTS,rowSpanLayouts:new Map,colSpanLayouts:new Map,cellAt:PLAIN,rectAt:()=>null,navigate:()=>null,expandRange:range=>range,access:()=>null,readMatrix:()=>null,covers:()=>false,report:()=>null}}export function spanColumns(host){const rowSpan=[];const colSpan=[];host.columns.forEach((column,index)=>{if(host.rowSpanOf(column)!==null)rowSpan.push(index);if(host.colSpanOf(column)!==null)colSpan.push(index)});return{rowSpan,colSpan}}export function rowLayoutStatus(host){const declared=spanColumns(host);if(declared.rowSpan.length===0&&declared.colSpan.length===0)return"not-configured";if(!host.clientSide)return"not-client-side";if(host.autoHeight)return"auto-height";return"ok"}function fullRowSpanLayout(state,host,column,callback){if(state.clampedRevision!==state.rowSpanCache.revision){state.clampedToMax.clear();state.clampedRevision=state.rowSpanCache.revision}const clamped=[];const capped=params=>{const requested=callback(params);if(typeof requested==="number"&&Number.isInteger(requested)&&requested>ROW_SPAN_MAX){clamped.push({reason:"clamped-to-max",index:params.index,requested,applied:ROW_SPAN_MAX,detail:`row span ${requested} exceeds the facade cap of ${ROW_SPAN_MAX} rows; painted as ${ROW_SPAN_MAX}`});return ROW_SPAN_MAX}return requested};const layout=resolveCachedRowSpanLayout(state.rowSpanCache,{rows:host.rows,column,rowSpan:capped,getSectionKey:host.sectionKeyOf});if(clamped.length>0)state.clampedToMax.set(column,Object.freeze(clamped.slice()));return{layout,clamped:state.clampedToMax.get(column)??[]}}export function buildRowLayoutFrame(state,host,window){const status=rowLayoutStatus(host);const rowCount=host.rows.length;const clampedWindow={startIndex:Math.max(0,Math.min(rowCount,Math.floor(window.startIndex))),endIndex:Math.max(0,Math.min(rowCount,Math.floor(window.endIndex)))};if(status!=="ok"||rowCount===0||host.columns.length===0)return inertFrame(status,clampedWindow);const declared=spanColumns(host);const columns=host.columns;const rowSpanLayouts=new Map;let renderRange=clampedWindow;for(const colIndex of declared.rowSpan){const column=columns[colIndex];const callback=host.rowSpanOf(column);if(callback===null)continue;const{layout}=fullRowSpanLayout(state,host,column,callback);rowSpanLayouts.set(colIndex,layout);const widened=rowSpanRenderRange(layout,clampedWindow);renderRange={startIndex:Math.min(renderRange.startIndex,widened.startIndex),endIndex:Math.max(renderRange.endIndex,widened.endIndex)}}const windowRows=host.rows.slice(renderRange.startIndex,renderRange.endIndex);const base=renderRange.startIndex;const rowSpanFor=params=>{const layout=rowSpanLayouts.get(params.column);if(layout===void 0)return 1;const absolute=base+params.index;const entry=rowSpanEntryAt(layout,absolute);if(entry===null||entry.originIndex!==absolute)return 1;return entry.span};const colSpanFor=params=>{const callback=host.colSpanOf(params.column);if(callback===null)return 1;return callback({...params,rowIndex:base+params.rowIndex})};const grid=resolveSpanGrid({rows:windowRows,columns,rowSpan:declared.rowSpan.length>0?rowSpanFor:void 0,colSpan:declared.colSpan.length>0?colSpanFor:void 0,getSectionKey:(row,index)=>host.sectionKeyOf(row,base+index),getContainer:host.containerOf});const colSpanLayouts=new Map;if(declared.colSpan.length>0){windowRows.forEach((row,index)=>{const layout=resolveColSpanLayout({columns,row,rowIndex:base+index,colSpan:params=>{const callback=host.colSpanOf(params.column);return callback===null?1:callback(params)},getContainer:host.containerOf});if(layout.spans.length>0||layout.rejected.length>0)colSpanLayouts.set(base+index,layout)})}const conflicts=grid.conflicts.map(conflict=>({...conflict,rowIndex:conflict.rowIndex+base}));const inWindow=rowIndex=>rowIndex>=renderRange.startIndex&&rowIndex<renderRange.endIndex;const rectAt=(rowIndex,colIndex)=>{if(!inWindow(rowIndex))return null;const rect=spanRectAt(grid,rowIndex-base,colIndex);if(rect===null)return null;return{...rect,rowIndex:rect.rowIndex+base,endRow:rect.endRow+base}};const heightOf=(originRow,span)=>{let height=0;for(let index=originRow;index<originRow+span&&index<rowCount;index+=1){height+=host.rowHeightAt(index)}return height};const widthOf=(originCol,span)=>{let widthPx=0;let flexGrow=0;let lastField=null;for(let index=originCol;index<originCol+span&&index<columns.length;index+=1){const column=columns[index];lastField=column.field;const width=host.widthOf(column,index);if(width===null){widthPx=null;flexGrow+=typeof column.flex==="number"&&column.flex>0?column.flex:1}else if(widthPx!==null){widthPx+=width}}return{widthPx,flexGrow:widthPx===null?flexGrow:null,lastField}};const cellAt=(rowIndex,colIndex)=>{const rect=rectAt(rowIndex,colIndex);if(rect===null)return PLAIN(rowIndex,colIndex);if(rect.rowIndex!==rowIndex||rect.colIndex!==colIndex){return{kind:"covered",rowSpan:rect.rowSpan,colSpan:rect.colSpan,origin:{rowIndex:rect.rowIndex,colIndex:rect.colIndex},heightPx:null,widthPx:null,flexGrow:null,lastField:null}}if(rect.rowSpan===1&&rect.colSpan===1)return PLAIN(rowIndex,colIndex);const layout=rowSpanLayouts.get(colIndex);const entry=layout===void 0?null:rowSpanEntryAt(layout,rowIndex);const rowSpan=entry!==null&&entry.originIndex===rowIndex?entry.span:rect.rowSpan;const width=widthOf(colIndex,rect.colSpan);return{kind:"origin",rowSpan,colSpan:rect.colSpan,origin:{rowIndex,colIndex},heightPx:rowSpan>1?heightOf(rowIndex,rowSpan):null,widthPx:rect.colSpan>1?width.widthPx:null,flexGrow:rect.colSpan>1?width.flexGrow:null,lastField:rect.colSpan>1?width.lastField:null}};return{status,configured:true,window:clampedWindow,renderRange,grid,conflicts,rowSpanLayouts,colSpanLayouts,cellAt,rectAt,navigate:(from,direction)=>{if(!inWindow(from.rowIndex))return null;const nav=navigateSpan(grid,{rowIndex:from.rowIndex-base,colIndex:from.colIndex},direction);if(nav===null)return null;if(!nav.moved)return null;return{rowIndex:nav.to.rowIndex+base,colIndex:nav.to.colIndex}},expandRange:range=>{const local=expandSpanRange(grid,{startRow:Math.max(0,range.startRow-base),endRow:Math.min(grid.rowCount,range.endRow-base),startCol:range.startCol,endCol:range.endCol});return{startRow:Math.min(range.startRow,local.startRow+base),endRow:Math.max(range.endRow,local.endRow+base),startCol:Math.min(range.startCol,local.startCol),endCol:Math.max(range.endCol,local.endCol)}},access:(feature,rowIndex,colIndex)=>{if(!inWindow(rowIndex))return null;const access=resolveSpanAccess(grid,feature,rowIndex-base,colIndex);if(access===null)return null;return{...access,requested:{rowIndex,colIndex},origin:{rowIndex:access.origin.rowIndex+base,colIndex:access.origin.colIndex},rect:{...access.rect,rowIndex:access.rect.rowIndex+base,endRow:access.rect.endRow+base}}},readMatrix:(range,mode,readValue)=>{if(range.startRow<renderRange.startIndex||range.endRow>renderRange.endIndex)return null;const matrix=spanValueMatrix(grid,{...range,startRow:range.startRow-base,endRow:range.endRow-base},mode,(origin,rect)=>readValue({rowIndex:origin.rowIndex+base,colIndex:origin.colIndex},{...rect,rowIndex:rect.rowIndex+base,endRow:rect.endRow+base}));return{...matrix,range:{...matrix.range,startRow:matrix.range.startRow+base,endRow:matrix.range.endRow+base},origins:matrix.origins.map(rect=>({...rect,rowIndex:rect.rowIndex+base,endRow:rect.endRow+base})),cells:matrix.cells.map(row=>row.map(cell=>cell===null?null:{...cell,origin:{rowIndex:cell.origin.rowIndex+base,colIndex:cell.origin.colIndex}}))}},covers:inWindow,report:()=>spanGridReport(grid)}}export function rowSpanReport(state,host,colId){const colIndex=host.columns.findIndex(column2=>(column2.colId??column2.field)===colId);if(colIndex<0)return null;const column=host.columns[colIndex];const status=rowLayoutStatus(host);const callback=host.rowSpanOf(column);const empty={colId,rowCount:host.rows.length,spans:[],rejected:[],callbackCalls:0,cache:rowSpanCacheStats(state.rowSpanCache),maxRowSpan:ROW_SPAN_MAX};if(callback===null)return{status:"not-configured",...empty};if(status!=="ok")return{status,...empty};const{layout,clamped}=fullRowSpanLayout(state,host,column,callback);return{status,colId,rowCount:layout.rowCount,spans:layout.spans.map(entry=>({originIndex:entry.originIndex,span:entry.span,endIndex:entry.endIndex})),rejected:[...layout.rejected,...clamped],callbackCalls:layout.callbackCalls,cache:rowSpanCacheStats(state.rowSpanCache),maxRowSpan:ROW_SPAN_MAX}}export function cellSpanInfo(state,host,rowIndex,colId){const colIndex=host.columns.findIndex(column2=>(column2.colId??column2.field)===colId);if(colIndex<0)return null;if(!Number.isInteger(rowIndex)||rowIndex<0||rowIndex>=host.rows.length)return null;const frame=buildRowLayoutFrame(state,host,{startIndex:Math.max(0,rowIndex-ROW_SPAN_MAX),endIndex:Math.min(host.rows.length,rowIndex+ROW_SPAN_MAX+1)});const column=host.columns[colIndex];const cell=frame.cellAt(rowIndex,colIndex);const rect=frame.rectAt(rowIndex,colIndex);const rowLayout=frame.rowSpanLayouts.get(colIndex);const colLayout=frame.colSpanLayouts.get(rowIndex);const originCell=cell.kind==="covered"?frame.cellAt(cell.origin.rowIndex,cell.origin.colIndex):cell;return{status:frame.status,rowIndex,colIndex,colId,origin:cell.origin,rowSpan:cell.rowSpan,colSpan:cell.colSpan,combination:rect===null?"single":rect.combination,covered:cell.kind==="covered",container:host.containerOf(column,colIndex),rect:{heightPx:originCell.heightPx??(frame.status==="ok"?host.rowHeightAt(cell.origin.rowIndex):null),widthPx:originCell.widthPx??(frame.status==="ok"?host.widthOf(column,colIndex):null)},rejected:{row:[...rowLayout===void 0?[]:rowLayout.rejected.filter(entry=>entry.index===rowIndex),...(state.clampedToMax.get(column)??[]).filter(entry=>entry.index===rowIndex)],column:colLayout===void 0?[]:colLayout.rejected.filter(entry=>entry.colIndex===colIndex)}}}export function spanInteractionReport(frame,exportMode,query){return{status:frame.status,window:frame.window,renderRange:frame.renderRange,report:frame.report(),conflicts:frame.conflicts,exportMode,access:query===null?null:frame.access(query.feature,query.rowIndex,query.colIndex)}}export function spanConflictSignature(conflicts){if(conflicts.length===0)return null;return conflicts.map(conflict=>`${conflict.reason}@${conflict.rowIndex},${conflict.colIndex}:${conflict.requestedRowSpan}x${conflict.requestedColSpan}`).sort().join("|")}export function widenedPadding(host,frame){let top=0;for(let index=frame.renderRange.startIndex;index<frame.window.startIndex;index+=1)top+=host.rowHeightAt(index);let bottom=0;for(let index=frame.window.endIndex;index<frame.renderRange.endIndex;index+=1)bottom+=host.rowHeightAt(index);return{top,bottom}}export function rowLayoutHostView(element,rows,uniform,rowHeightFn){const columns=element.effectiveColumns();return{rows,columns,rowSpanOf:column=>typeof column.rowSpan==="function"?params=>column.rowSpan(params):null,colSpanOf:column=>typeof column.colSpan==="function"?params=>column.colSpan(params):null,sectionKeyOf:(row,index)=>element.isSentinelDisplayRow(row)?`sentinel:${index}`:null,containerOf:column=>element.pinSideOf(column)??"middle",rowHeightAt:index=>typeof rowHeightFn==="function"?element.rowHeightForIndex(rowHeightFn,index,rows[index],uniform):uniform,widthOf:column=>element.pinnedWidthOf(column),clientSide:!element.serverSideModeActive()&&element.viewportState===null&&element.infiniteCache===null,autoHeight:element.autoHeightActive()}}export function spansDeclared(columns){return columns.some(column=>typeof column.rowSpan==="function"||typeof column.colSpan==="function")}export function spanAwareMove(frame,from,direction,fallback){if(frame===null||!frame.configured||from===null)return fallback;const target=frame.navigate(from,direction);if(target!==null)return target;if(fallback===null||!frame.covers(fallback.rowIndex))return fallback;const cell=frame.cellAt(fallback.rowIndex,fallback.colIndex);return cell.kind==="covered"?cell.origin:fallback}export function spanAwareCellText(frame,mode,rowIndex,colIndex,read){if(frame!==null&&frame.configured&&frame.covers(rowIndex)){const cell=frame.cellAt(rowIndex,colIndex);if(cell.kind==="covered")return mode==="repeat"?read(cell.origin.rowIndex,cell.origin.colIndex):""}return read(rowIndex,colIndex)}export function spanInteractionFor(state,host,frame,window,exportMode,query){const resolved=frame!==null&&frame.configured?frame:buildRowLayoutFrame(state,host,window);let address=null;if(query!==void 0&&query!==null){const colIndex=host.columns.findIndex(column=>(column.colId??column.field)===query.colId);if(colIndex>=0)address={feature:query.feature,rowIndex:Number(query.rowIndex),colIndex}}return spanInteractionReport(resolved,exportMode,address)}export{measureRowSpanGeometry};

package/dist/collection/components/grid/core/row-layout/row-span.js

@@ -0,0 +1 @@
+export const ROW_SPAN_REJECTION_REASONS=Object.freeze(["invalid-span","callback-threw","non-deterministic","clamped-to-section","clamped-to-end"]);const EMPTY_SPANS=Object.freeze([]);const EMPTY_REJECTIONS=Object.freeze([]);const isUsableSpan=value=>typeof value==="number"&&Number.isInteger(value)&&value>=1;export function resolveRowSpanLayout(options){const{rows,column,rowSpan,getSectionKey,verifyDeterminism=false}=options;const rowCount=rows.length;if(rowCount===0){return{column,rowCount:0,spans:EMPTY_SPANS,rejected:EMPTY_REJECTIONS,callbackCalls:0}}const sectionKeyAt=index2=>getSectionKey===void 0?null:getSectionKey(rows[index2],index2);const spans=[];const rejected=[];let callbackCalls=0;let index=0;while(index<rowCount){const sectionKey=sectionKeyAt(index);const params={row:rows[index],index,column,sectionKey};let requested=null;let threw=false;try{callbackCalls+=1;const answer=rowSpan(params);requested=typeof answer==="number"?answer:null;if(verifyDeterminism){callbackCalls+=1;const again=rowSpan(params);if(!Object.is(answer,again)){rejected.push({reason:"non-deterministic",index,requested:typeof answer==="number"?answer:null,applied:1,detail:`rowSpan at row ${index} answered ${String(answer)} then ${String(again)} for identical params; a span callback must be a pure function of its params`});index+=1;continue}}if(!isUsableSpan(answer)){rejected.push({reason:"invalid-span",index,requested,applied:1,detail:`rowSpan at row ${index} returned ${String(answer)}; a span must be an integer >= 1`});index+=1;continue}requested=answer}catch(error){threw=true;rejected.push({reason:"callback-threw",index,requested:null,applied:1,detail:`rowSpan at row ${index} threw (${error instanceof Error?error.message:String(error)}); the cell falls back to span 1`})}if(threw||requested===null){index+=1;continue}let end=index+requested;if(end>rowCount){rejected.push({reason:"clamped-to-end",index,requested,applied:rowCount-index,detail:`rowSpan at row ${index} asked for ${requested} rows but only ${rowCount-index} remain in the display list`});end=rowCount}let boundary=end;for(let probe=index+1;probe<end;probe+=1){if(!Object.is(sectionKeyAt(probe),sectionKey)){boundary=probe;break}}if(boundary<end){rejected.push({reason:"clamped-to-section",index,requested,applied:boundary-index,detail:`rowSpan at row ${index} would have crossed the section boundary at row ${boundary} (section ${JSON.stringify(sectionKey)}); it was cut to ${boundary-index} rows`});end=boundary}if(end-index>1)spans.push({originIndex:index,span:end-index,endIndex:end});index=end}return{column,rowCount,spans,rejected:rejected.length===0?EMPTY_REJECTIONS:rejected,callbackCalls}}function findSpanSlot(layout,index){const spans=layout.spans;let lo=0;let hi=spans.length-1;while(lo<=hi){const mid=lo+hi>>>1;const entry=spans[mid];if(index<entry.originIndex)hi=mid-1;else if(index>=entry.endIndex)lo=mid+1;else return mid}return-1}export function rowSpanEntryAt(layout,index){if(!Number.isInteger(index)||index<0||index>=layout.rowCount)return null;const slot=findSpanSlot(layout,index);if(slot<0)return{originIndex:index,span:1,endIndex:index+1};return layout.spans[slot]}export function rowSpanOriginAt(layout,index){return rowSpanEntryAt(layout,index)?.originIndex??-1}export function isRowSpanCovered(layout,index){const entry=rowSpanEntryAt(layout,index);return entry!==null&&entry.originIndex!==index}export function rowSpanOrigins(layout){const origins=[];let index=0;for(const entry of layout.spans){for(;index<entry.originIndex;index+=1)origins.push(index);origins.push(entry.originIndex);index=entry.endIndex}for(;index<layout.rowCount;index+=1)origins.push(index);return origins}export const ROW_SPAN_INVALIDATION_REASONS=Object.freeze(["sort","filter","group","data","height","columns","manual"]);export function createRowSpanCache(){return{entries:new Map,revision:1,hits:0,misses:0,invalidations:0,lastReason:null}}export function invalidateRowSpans(cache,reason,column){if(column===void 0)cache.entries.clear();else cache.entries.delete(column);cache.revision+=1;cache.invalidations+=1;cache.lastReason=reason}export function resolveCachedRowSpanLayout(cache,options){const cached=cache.entries.get(options.column);if(cached!==void 0&&cached.rows===options.rows&&cached.revision===cache.revision){cache.hits+=1;return cached.layout}cache.misses+=1;const layout=resolveRowSpanLayout(options);cache.entries.set(options.column,{rows:options.rows,revision:cache.revision,layout});return layout}export function rowSpanCacheStats(cache){return{revision:cache.revision,entries:cache.entries.size,hits:cache.hits,misses:cache.misses,invalidations:cache.invalidations,lastReason:cache.lastReason}}export function createUniformRowSpanMetrics(rowHeight){if(!Number.isFinite(rowHeight)||rowHeight<=0){throw new RangeError(`[Syidax] createUniformRowSpanMetrics: rowHeight must be a finite positive number, got ${rowHeight}.`)}return{offsetAt:index=>Math.max(0,index)*rowHeight}}export function rowSpanRenderRange(layout,window){const startIndex=Math.max(0,Math.min(layout.rowCount,Math.floor(window.startIndex)));const endIndex=Math.max(startIndex,Math.min(layout.rowCount,Math.floor(window.endIndex)));if(startIndex>=endIndex)return{startIndex,endIndex};const first=rowSpanEntryAt(layout,startIndex);const last=rowSpanEntryAt(layout,endIndex-1);return{startIndex:first===null?startIndex:first.originIndex,endIndex:last===null?endIndex:last.endIndex}}export function measureRowSpanGeometry(layout,window,metrics){const range=rowSpanRenderRange(layout,window);const visibleStart=Math.max(0,Math.min(layout.rowCount,Math.floor(window.startIndex)));const visibleEnd=Math.max(visibleStart,Math.min(layout.rowCount,Math.floor(window.endIndex)));const placements=[];let index=range.startIndex;while(index<range.endIndex){const entry=rowSpanEntryAt(layout,index);if(entry===null)break;const top=metrics.offsetAt(entry.originIndex);placements.push({originIndex:entry.originIndex,span:entry.span,endIndex:entry.endIndex,top,height:metrics.offsetAt(entry.endIndex)-top,startsAboveWindow:entry.originIndex<visibleStart,endsBelowWindow:entry.endIndex>visibleEnd});index=entry.endIndex}return placements}

package/dist/collection/components/grid/core/row-layout/span-interaction.js

@@ -0,0 +1 @@
+import{isRowSpanCovered,resolveRowSpanLayout,rowSpanEntryAt}from"./row-span.js";import{colSpanEntryAt,isColSpanCovered,resolveColSpanLayout}from"./col-span.js";export const SPAN_COMBINATIONS=Object.freeze(["single","row","column","rectangular"]);export function spanCombinationOf(rowSpan,colSpan){if(rowSpan>1&&colSpan>1)return"rectangular";if(rowSpan>1)return"row";if(colSpan>1)return"column";return"single"}export const SPAN_CONFLICT_REASONS=Object.freeze(["ragged-row-span","ragged-col-span","overlapping-rect","dropped-cover"]);const EMPTY_RECTS=Object.freeze([]);const EMPTY_CONFLICTS=Object.freeze([]);const ONE=()=>1;export function resolveSpanGrid(options){const{rows,columns,verifyDeterminism=false}=options;const rowCount=rows.length;const columnCount=columns.length;if(rowCount===0||columnCount===0){return{rowCount,columnCount,rects:EMPTY_RECTS,conflicts:EMPTY_CONFLICTS,rowLayouts:[],colLayouts:[],owners:[]}}const rowSpan=options.rowSpan??ONE;const colSpan=options.colSpan??ONE;const rowLayouts=[];for(let colIndex=0;colIndex<columnCount;colIndex+=1){rowLayouts.push(resolveRowSpanLayout({rows,column:colIndex,rowSpan,getSectionKey:options.getSectionKey,verifyDeterminism}))}const colLayouts=[];for(let rowIndex=0;rowIndex<rowCount;rowIndex+=1){colLayouts.push(resolveColSpanLayout({columns,row:rows[rowIndex],rowIndex,colSpan,getContainer:options.getContainer,getBoundaryKey:options.getBoundaryKey,verifyDeterminism}))}const owners=new Array(rowCount*columnCount).fill(-1);const rects=[];const conflicts=[];const at=(rowIndex,colIndex)=>rowIndex*columnCount+colIndex;for(let rowIndex=0;rowIndex<rowCount;rowIndex+=1){for(let colIndex=0;colIndex<columnCount;colIndex+=1){if(owners[at(rowIndex,colIndex)]!==-1)continue;const rowEntry=rowSpanEntryAt(rowLayouts[colIndex],rowIndex);const colEntry=colSpanEntryAt(colLayouts[rowIndex],colIndex);const rowIsOrigin=rowEntry!==null&&rowEntry.originIndex===rowIndex;const colIsOrigin=colEntry!==null&&colEntry.originIndex===colIndex;const requestedRowSpan=rowIsOrigin?rowEntry.span:1;const requestedColSpan=colIsOrigin?colEntry.span:1;if(!rowIsOrigin||!colIsOrigin){conflicts.push({reason:"dropped-cover",rowIndex,colIndex,requestedRowSpan,requestedColSpan,appliedRowSpan:1,appliedColSpan:1,detail:`cell (${rowIndex}, ${colIndex}) is covered by the ${rowIsOrigin?"column":"row"}-axis layout but nothing claimed it, so the rectangle that should have covered it was refused; it renders as its own cell`});owners[at(rowIndex,colIndex)]=rects.length;rects.push({rowIndex,colIndex,rowSpan:1,colSpan:1,endRow:rowIndex+1,endCol:colIndex+1,combination:"single"});continue}let appliedRowSpan=requestedRowSpan;let appliedColSpan=requestedColSpan;let refusal=null;let detail="";if(appliedColSpan>1){for(let probe=colIndex+1;probe<colIndex+appliedColSpan;probe+=1){const other=rowSpanEntryAt(rowLayouts[probe],rowIndex);if(other===null||other.originIndex!==rowIndex||other.span!==appliedRowSpan){refusal="ragged-row-span";detail=`cell (${rowIndex}, ${colIndex}) asked for ${appliedRowSpan} row(s) x ${appliedColSpan} column(s), but column ${probe} spans ${other===null||other.originIndex!==rowIndex?"a different origin":String(other.span)} row(s) at that row, so the region is not a rectangle`;break}}}if(refusal===null&&appliedRowSpan>1){for(let probe=rowIndex+1;probe<rowIndex+appliedRowSpan;probe+=1){const other=colSpanEntryAt(colLayouts[probe],colIndex);if(other===null||other.originIndex!==colIndex||other.span!==appliedColSpan){refusal="ragged-col-span";detail=`cell (${rowIndex}, ${colIndex}) asked for ${appliedRowSpan} row(s) x ${appliedColSpan} column(s), but row ${probe} spans ${other===null||other.originIndex!==colIndex?"a different origin":String(other.span)} column(s) at that column, so the region is not a rectangle`;break}}}if(refusal===null&&(appliedRowSpan>1||appliedColSpan>1)){outer:for(let r=rowIndex;r<rowIndex+appliedRowSpan;r+=1){for(let c=colIndex;c<colIndex+appliedColSpan;c+=1){if(owners[at(r,c)]!==-1){refusal="overlapping-rect";detail=`cell (${rowIndex}, ${colIndex}) asked for ${appliedRowSpan} row(s) x ${appliedColSpan} column(s), but (${r}, ${c}) is already owned by the cell at (${rects[owners[at(r,c)]].rowIndex}, ${rects[owners[at(r,c)]].colIndex}); two origins may not own one cell`;break outer}}}}if(refusal!==null){conflicts.push({reason:refusal,rowIndex,colIndex,requestedRowSpan,requestedColSpan,appliedRowSpan:1,appliedColSpan:1,detail});appliedRowSpan=1;appliedColSpan=1}const slot=rects.length;rects.push({rowIndex,colIndex,rowSpan:appliedRowSpan,colSpan:appliedColSpan,endRow:rowIndex+appliedRowSpan,endCol:colIndex+appliedColSpan,combination:spanCombinationOf(appliedRowSpan,appliedColSpan)});for(let r=rowIndex;r<rowIndex+appliedRowSpan;r+=1){for(let c=colIndex;c<colIndex+appliedColSpan;c+=1){owners[at(r,c)]=slot}}}}return{rowCount,columnCount,rects,conflicts:conflicts.length===0?EMPTY_CONFLICTS:conflicts,rowLayouts,colLayouts,owners}}const inGrid=(grid,rowIndex,colIndex)=>Number.isInteger(rowIndex)&&Number.isInteger(colIndex)&&rowIndex>=0&&rowIndex<grid.rowCount&&colIndex>=0&&colIndex<grid.columnCount;export function spanRectAt(grid,rowIndex,colIndex){if(!inGrid(grid,rowIndex,colIndex))return null;const slot=grid.owners[rowIndex*grid.columnCount+colIndex];return slot===void 0||slot<0?null:grid.rects[slot]}export function spanOriginAt(grid,rowIndex,colIndex){const rect=spanRectAt(grid,rowIndex,colIndex);return rect===null?null:{rowIndex:rect.rowIndex,colIndex:rect.colIndex}}export function isSpanCovered(grid,rowIndex,colIndex){const rect=spanRectAt(grid,rowIndex,colIndex);if(rect===null)return false;return rect.rowIndex!==rowIndex||rect.colIndex!==colIndex}export function isSpanOrigin(grid,rowIndex,colIndex){const rect=spanRectAt(grid,rowIndex,colIndex);return rect!==null&&rect.rowIndex===rowIndex&&rect.colIndex===colIndex}export const SPAN_FEATURES=Object.freeze(["selection","focus","edit","copy","fill","export","aria"]);const MUTATING_FEATURES=new Set(["edit","fill"]);export function resolveSpanAccess(grid,feature,rowIndex,colIndex){const rect=spanRectAt(grid,rowIndex,colIndex);if(rect===null)return null;return{feature,requested:{rowIndex,colIndex},origin:{rowIndex:rect.rowIndex,colIndex:rect.colIndex},rect,redirected:rect.rowIndex!==rowIndex||rect.colIndex!==colIndex,mutating:MUTATING_FEATURES.has(feature)}}const clampRange=(grid,range)=>{const startRow=Math.max(0,Math.min(grid.rowCount,Math.floor(range.startRow)));const endRow=Math.max(startRow,Math.min(grid.rowCount,Math.floor(range.endRow)));const startCol=Math.max(0,Math.min(grid.columnCount,Math.floor(range.startCol)));const endCol=Math.max(startCol,Math.min(grid.columnCount,Math.floor(range.endCol)));return{startRow,endRow,startCol,endCol}};export function expandSpanRange(grid,range){let current=clampRange(grid,range);if(current.startRow>=current.endRow||current.startCol>=current.endCol)return current;for(let guard=0;guard<=grid.rowCount+grid.columnCount;guard+=1){let startRow=current.startRow;let endRow=current.endRow;let startCol=current.startCol;let endCol=current.endCol;for(let rowIndex=current.startRow;rowIndex<current.endRow;rowIndex+=1){for(let colIndex=current.startCol;colIndex<current.endCol;colIndex+=1){const rect=spanRectAt(grid,rowIndex,colIndex);if(rect===null)continue;if(rect.rowIndex<startRow)startRow=rect.rowIndex;if(rect.endRow>endRow)endRow=rect.endRow;if(rect.colIndex<startCol)startCol=rect.colIndex;if(rect.endCol>endCol)endCol=rect.endCol}}if(startRow===current.startRow&&endRow===current.endRow&&startCol===current.startCol&&endCol===current.endCol){return current}current={startRow,endRow,startCol,endCol}}return current}export function enumerateSpanCells(grid,range){const bounds=clampRange(grid,range);const seen=new Set;const out=[];for(let rowIndex=bounds.startRow;rowIndex<bounds.endRow;rowIndex+=1){for(let colIndex=bounds.startCol;colIndex<bounds.endCol;colIndex+=1){const slot=grid.owners[rowIndex*grid.columnCount+colIndex];if(slot===void 0||slot<0||seen.has(slot))continue;seen.add(slot);out.push(grid.rects[slot])}}return out}export const SPAN_EXPORT_MODES=Object.freeze(["origin-once","repeat"]);export function spanValueMatrix(grid,range,mode,readValue){const bounds=clampRange(grid,range);const origins=enumerateSpanCells(grid,bounds);const values=new Map;for(const rect of origins){values.set(rect.rowIndex*grid.columnCount+rect.colIndex,readValue({rowIndex:rect.rowIndex,colIndex:rect.colIndex},rect))}const cells=[];for(let rowIndex=bounds.startRow;rowIndex<bounds.endRow;rowIndex+=1){const line=[];for(let colIndex=bounds.startCol;colIndex<bounds.endCol;colIndex+=1){const rect=spanRectAt(grid,rowIndex,colIndex);if(rect===null){line.push(null);continue}const isOrigin=rect.rowIndex===rowIndex&&rect.colIndex===colIndex;if(!isOrigin&&mode==="origin-once"){line.push(null);continue}line.push({origin:{rowIndex:rect.rowIndex,colIndex:rect.colIndex},value:values.get(rect.rowIndex*grid.columnCount+rect.colIndex),isOrigin})}cells.push(line)}return{range:bounds,cells,origins,reads:origins.length}}export const SPAN_NAV_DIRECTIONS=Object.freeze(["up","down","left","right"]);export function navigateSpan(grid,from,direction){const origin=spanRectAt(grid,from.rowIndex,from.colIndex);if(origin===null)return null;let targetRow=origin.rowIndex;let targetCol=origin.colIndex;switch(direction){case"up":targetRow=origin.rowIndex-1;break;case"down":targetRow=origin.endRow;break;case"left":targetCol=origin.colIndex-1;break;case"right":targetCol=origin.endCol;break;default:{const never=direction;throw new Error(`unknown span navigation direction: ${JSON.stringify(never)}`)}}const target=spanRectAt(grid,targetRow,targetCol);if(target===null)return{from:origin,to:origin,moved:false};return{from:origin,to:target,moved:target.rowIndex!==origin.rowIndex||target.colIndex!==origin.colIndex}}export function spanAriaAttributes(grid,rowIndex,colIndex){const rect=spanRectAt(grid,rowIndex,colIndex);if(rect===null)return null;if(rect.rowIndex!==rowIndex||rect.colIndex!==colIndex)return null;const attrs={"aria-rowindex":rect.rowIndex+1,"aria-colindex":rect.colIndex+1};if(rect.rowSpan>1)attrs["aria-rowspan"]=rect.rowSpan;if(rect.colSpan>1)attrs["aria-colspan"]=rect.colSpan;return attrs}export function spanGridReport(grid){const combinations={single:0,row:0,column:0,rectangular:0};let coveredCount=0;for(const rect of grid.rects){combinations[rect.combination]+=1;coveredCount+=rect.rowSpan*rect.colSpan-1}const conflicts={"ragged-row-span":0,"ragged-col-span":0,"overlapping-rect":0,"dropped-cover":0};for(const conflict of grid.conflicts)conflicts[conflict.reason]+=1;return{rowCount:grid.rowCount,columnCount:grid.columnCount,cellCount:grid.rects.length,coveredCount,combinations,conflicts,rowAxisRejections:grid.rowLayouts.reduce((sum,layout)=>sum+layout.rejected.length,0),colAxisRejections:grid.colLayouts.reduce((sum,layout)=>sum+layout.rejected.length,0)}}export function spanAxesAgreeAt(grid,rowIndex,colIndex){const rect=spanRectAt(grid,rowIndex,colIndex);if(rect===null)return false;const rowLayout=grid.rowLayouts[colIndex];const colLayout=grid.colLayouts[rowIndex];if(rowLayout===void 0||colLayout===void 0)return false;const rowCovered=isRowSpanCovered(rowLayout,rowIndex);const colCovered=isColSpanCovered(colLayout,colIndex);const gridCovered=rect.rowIndex!==rowIndex||rect.colIndex!==colIndex;return gridCovered===(rowCovered||colCovered)}

package/dist/collection/components/grid/core/row-markers.js

@@ -0,0 +1 @@
+export const BLANK_GROUP_KEY=" __sy_blank__";export function isGroupMarkerRow(row){return row!==null&&typeof row==="object"&&row.__syGroupRow===true}export function isAggregatedGroupMarkerRow(row){return row!==null&&typeof row==="object"&&row.__syGroupRow===true&&typeof row.aggregates==="object"&&row.aggregates!==null}export function isGroupFooterRow(row){return row!==null&&typeof row==="object"&&row.__syGroupFooter===true}export function foldGroupKey(raw){if(raw===null||raw===void 0)return null;if(typeof raw==="number"&&Number.isNaN(raw))return null;if(raw instanceof Date){const ms=raw.getTime();return Number.isNaN(ms)?null:raw.toISOString()}return String(raw)}export function isTreeNodeRow(row){return row!==null&&typeof row==="object"&&row.__syTreeRow===true}export const TREE_PATH_KEY_SEPARATOR="";export function foldTreePathKey(path){return path.join(TREE_PATH_KEY_SEPARATOR)}export function isDetailRow(row){return row!==null&&typeof row==="object"&&row.__syDetailRow===true}export function isPivotRowGroupMarker(row){return typeof row==="object"&&row!==null&&row.__syPivotRow===true}export function isPivotGrandTotalRow(row){return typeof row==="object"&&row!==null&&row.__syPivotGrandTotal===true}export function frameSegmentPath(segments){const separator=String.fromCharCode(31);let out="";for(const segment of segments)out+=`${segment.length}${separator}${segment}`;return out}export const PIVOT_ROW_HEADER_COL_ID="__sy_pivot_rowheader__";export function isPivotColumnId(field){return typeof field==="string"&&field.startsWith("__sy_pivot__")}

package/dist/collection/components/grid/core/row-model/block-cache.js

@@ -0,0 +1 @@
+export const DEFAULT_BLOCK_SIZE=100;export function blockNumberForRow(rowIndex,blockSize){return Math.floor(rowIndex/blockSize)}export function blockBounds(blockNumber,blockSize){const startRow=blockNumber*blockSize;return{startRow,endRow:startRow+blockSize}}function clampBlockSize(size){if(typeof size==="number"&&Number.isInteger(size)&&size>=1)return size;return DEFAULT_BLOCK_SIZE}function clampMaxBlocks(max){if(max===null||max===void 0)return null;if(Number.isInteger(max)&&max>=1)return max;return null}export function createInfiniteCache(config){return{blocks:{},blockSize:clampBlockSize(config?.blockSize),maxBlocks:clampMaxBlocks(config?.maxBlocks),rowCount:0,lastRowKnown:false,accessSeq:0}}export function virtualRowCount(state){if(state.lastRowKnown)return state.rowCount;return Math.max(state.rowCount+1,1)}export function blocksForRange(startRow,endRow,blockSize){const out=[];if(endRow<=startRow)return out;const first=blockNumberForRow(Math.max(0,startRow),blockSize);const last=blockNumberForRow(Math.max(0,endRow-1),blockSize);for(let b=first;b<=last;b++)out.push(b);return out}export function lookupRow(state,rowIndex){if(rowIndex<0)return{status:"missing"};const block=state.blocks[blockNumberForRow(rowIndex,state.blockSize)];if(block===void 0)return{status:"missing"};if(block.status==="loading")return{status:"loading"};if(block.status==="failed")return{status:"failed"};const rows=block.rows;if(rows===null)return{status:"missing"};const offset=rowIndex-block.blockNumber*state.blockSize;if(offset<0||offset>=rows.length)return{status:"missing"};return{status:"loaded",row:rows[offset]}}export function blocksToLoadForRange(state,startRow,endRow,includeFailed=false){return blocksForRange(startRow,endRow,state.blockSize).filter(b=>{const block=state.blocks[b];if(block===void 0)return true;if(block.status==="failed")return includeFailed;return false})}export function markBlockLoading(state,blockNumber){const existing=state.blocks[blockNumber];if(existing!==void 0&&existing.status==="loading")return state;const accessSeq=state.accessSeq+1;return{...state,accessSeq,blocks:{...state.blocks,[blockNumber]:{blockNumber,status:"loading",rows:null,lastAccess:accessSeq}}}}export function applyBlockSuccess(state,blockNumber,rows,lastRow=null){const accessSeq=state.accessSeq+1;const blockEnd=blockNumber*state.blockSize+rows.length;let rowCount=state.rowCount;let lastRowKnown=state.lastRowKnown;if(typeof lastRow==="number"&&lastRow>=0){rowCount=lastRow;lastRowKnown=true}else if(rows.length<state.blockSize){rowCount=blockEnd;lastRowKnown=true}else if(!state.lastRowKnown){rowCount=Math.max(state.rowCount,blockEnd)}const next={...state,accessSeq,rowCount,lastRowKnown,blocks:{...state.blocks,[blockNumber]:{blockNumber,status:"loaded",rows,lastAccess:accessSeq}}};return evictOverflow(next)}export function applyBlockFailure(state,blockNumber){const existing=state.blocks[blockNumber];if(existing!==void 0&&existing.status==="failed")return state;const accessSeq=state.accessSeq+1;return{...state,accessSeq,blocks:{...state.blocks,[blockNumber]:{blockNumber,status:"failed",rows:null,lastAccess:accessSeq}}}}export function touchRange(state,startRow,endRow){const nums=blocksForRange(startRow,endRow,state.blockSize).filter(b=>state.blocks[b]!==void 0);if(nums.length===0)return state;let accessSeq=state.accessSeq;const blocks={...state.blocks};for(const b of nums){accessSeq+=1;blocks[b]={...blocks[b],lastAccess:accessSeq}}return{...state,accessSeq,blocks}}export function evictOverflow(state){if(state.maxBlocks===null)return state;const loaded=Object.values(state.blocks).filter(b=>b.status==="loaded");const overflow=loaded.length-state.maxBlocks;if(overflow<=0)return state;const victims=loaded.slice().sort((a,b)=>a.lastAccess-b.lastAccess).slice(0,overflow);const blocks={...state.blocks};for(const v of victims)delete blocks[v.blockNumber];return{...state,blocks}}export function purgeCache(state){return{...state,blocks:{},rowCount:0,lastRowKnown:false,accessSeq:state.accessSeq+1}}export function loadedBlockCount(state){let n=0;for(const b of Object.values(state.blocks))if(b.status==="loaded")n++;return n}