@syidax/advanced 0.0.0-stage → 1.0.1

package/dist/collection/components/grid/core/cell-cycle.js

@@ -0,0 +1 @@
+function safeCount(raw){if(typeof raw!=="number"||!Number.isFinite(raw))return 0;if(raw<=0)return 0;return Math.floor(raw)}function isValid(active,rowCount,colCount){if(!active)return false;if(typeof active.rowIndex!=="number"||typeof active.colIndex!=="number")return false;if(!Number.isInteger(active.rowIndex)||!Number.isInteger(active.colIndex))return false;if(active.rowIndex<0||active.colIndex<0)return false;if(active.rowIndex>=rowCount||active.colIndex>=colCount)return false;return true}export function moveCell(active,direction,rowCount,colCount){const rows=safeCount(rowCount);const cols=safeCount(colCount);if(rows===0||cols===0)return null;if(!isValid(active,rows,cols)){return{rowIndex:0,colIndex:0}}switch(direction){case"up":if(active.rowIndex<=0)return active;return{rowIndex:active.rowIndex-1,colIndex:active.colIndex};case"down":if(active.rowIndex>=rows-1)return active;return{rowIndex:active.rowIndex+1,colIndex:active.colIndex};case"left":if(active.colIndex<=0)return active;return{rowIndex:active.rowIndex,colIndex:active.colIndex-1};case"right":if(active.colIndex>=cols-1)return active;return{rowIndex:active.rowIndex,colIndex:active.colIndex+1};default:{const _exhaustive=direction;void _exhaustive;return active}}}export function tabCell(active,reverse,rowCount,colCount){const rows=safeCount(rowCount);const cols=safeCount(colCount);if(rows===0||cols===0)return null;if(!isValid(active,rows,cols)){if(reverse){return{rowIndex:rows-1,colIndex:cols-1}}return{rowIndex:0,colIndex:0}}if(reverse){if(active.colIndex>0){return{rowIndex:active.rowIndex,colIndex:active.colIndex-1}}if(active.rowIndex>0){return{rowIndex:active.rowIndex-1,colIndex:cols-1}}return active}if(active.colIndex<cols-1){return{rowIndex:active.rowIndex,colIndex:active.colIndex+1}}if(active.rowIndex<rows-1){return{rowIndex:active.rowIndex+1,colIndex:0}}return active}export function clampCell(active,rowCount,colCount){const rows=safeCount(rowCount);const cols=safeCount(colCount);if(rows===0||cols===0)return null;if(!active)return null;if(typeof active.rowIndex!=="number"||typeof active.colIndex!=="number"||!Number.isFinite(active.rowIndex)||!Number.isFinite(active.colIndex)){return null}let nextRow=Math.floor(active.rowIndex);let nextCol=Math.floor(active.colIndex);if(nextRow<0)nextRow=0;if(nextCol<0)nextCol=0;if(nextRow>=rows)nextRow=rows-1;if(nextCol>=cols)nextCol=cols-1;if(nextRow===active.rowIndex&&nextCol===active.colIndex){return active}return{rowIndex:nextRow,colIndex:nextCol}}export function homeCell(active,colCount){const cols=safeCount(colCount);if(cols===0)return null;if(!active||typeof active.rowIndex!=="number"||!Number.isInteger(active.rowIndex)||active.rowIndex<0){return{rowIndex:0,colIndex:0}}if(active.colIndex===0)return active;return{rowIndex:active.rowIndex,colIndex:0}}export function endCell(active,colCount){const cols=safeCount(colCount);if(cols===0)return null;const lastCol=cols-1;if(!active||typeof active.rowIndex!=="number"||!Number.isInteger(active.rowIndex)||active.rowIndex<0){return{rowIndex:0,colIndex:lastCol}}if(active.colIndex===lastCol)return active;return{rowIndex:active.rowIndex,colIndex:lastCol}}export function homeGridCell(rowCount,colCount){const rows=safeCount(rowCount);const cols=safeCount(colCount);if(rows===0||cols===0)return null;return{rowIndex:0,colIndex:0}}export function endGridCell(rowCount,colCount){const rows=safeCount(rowCount);const cols=safeCount(colCount);if(rows===0||cols===0)return null;return{rowIndex:rows-1,colIndex:cols-1}}export function pageCell(active,direction,pageSize,rowCount,colCount){const rows=safeCount(rowCount);const cols=safeCount(colCount);if(rows===0||cols===0)return null;const safePage=safeCount(pageSize);if(!isValid(active,rows,cols)){if(direction==="down")return{rowIndex:0,colIndex:0};return{rowIndex:rows-1,colIndex:cols-1}}if(safePage===0)return active;let nextRow;if(direction==="down"){nextRow=active.rowIndex+safePage;if(nextRow>rows-1)nextRow=rows-1}else{nextRow=active.rowIndex-safePage;if(nextRow<0)nextRow=0}if(nextRow===active.rowIndex)return active;return{rowIndex:nextRow,colIndex:active.colIndex}}export function moveCellWithWrap(active,direction,rowCount,colCount){const rows=safeCount(rowCount);const cols=safeCount(colCount);if(rows===0||cols===0)return null;if(!isValid(active,rows,cols)){return{rowIndex:0,colIndex:0}}if(direction==="up"||direction==="down"){return moveCell(active,direction,rows,cols)}if(direction==="right"){if(active.colIndex<cols-1){return{rowIndex:active.rowIndex,colIndex:active.colIndex+1}}if(active.rowIndex<rows-1){return{rowIndex:active.rowIndex+1,colIndex:0}}return active}if(active.colIndex>0){return{rowIndex:active.rowIndex,colIndex:active.colIndex-1}}if(active.rowIndex>0){return{rowIndex:active.rowIndex-1,colIndex:cols-1}}return active}

package/dist/collection/components/grid/core/cell-flash/cell-flash.js

@@ -0,0 +1 @@
+export function cellFlashKey(rowIndex,field){return`${rowIndex}::${field}`}export function addFlash(set,key){if(set.has(key))return set;const next=new Set(set);next.add(key);return next}export function removeFlash(set,key){if(!set.has(key))return set;const next=new Set(set);next.delete(key);return next}export function hasFlash(set,key){return set.has(key)}

package/dist/collection/components/grid/core/cell-tooltip/hover-delay.js

@@ -0,0 +1 @@
+const DEFAULT_SHOW_MS=400;const DEFAULT_HIDE_MS=100;export function createHoverDelay(options){const showMs=Number.isFinite(options.showMs)&&options.showMs>=0?options.showMs:DEFAULT_SHOW_MS;const hideMs=Number.isFinite(options.hideMs)&&options.hideMs>=0?options.hideMs:DEFAULT_HIDE_MS;const schedule=options.schedule??((fn,ms)=>setTimeout(fn,ms));const cancel=options.cancel??(h=>clearTimeout(h));let state="idle";let timer=null;let pendingTarget=null;function clear(){if(timer!==null){cancel(timer);timer=null}}return{get state(){return state},enter(target){const previousTarget=pendingTarget;pendingTarget=target;if(state==="shown"){clear();state="shown";if(previousTarget!==target)options.onShow(target);return}if(state==="pending-hide"){clear();state="shown";if(previousTarget!==target)options.onShow(target);return}clear();state="pending-show";timer=schedule(()=>{timer=null;state="shown";const t=pendingTarget;if(t!==null)options.onShow(t)},showMs)},leave(){if(state==="idle")return;if(state==="pending-show"){clear();state="idle";pendingTarget=null;return}clear();state="pending-hide";timer=schedule(()=>{timer=null;state="idle";pendingTarget=null;options.onHide()},hideMs)},cancel(){clear();state="idle";pendingTarget=null}}}

package/dist/collection/components/grid/core/cell-tooltip/index.js

@@ -0,0 +1 @@
+export*from"./tooltip-text.js";export*from"./hover-delay.js";

package/dist/collection/components/grid/core/cell-tooltip/tooltip-text.js

@@ -0,0 +1 @@
+import{resolveCellValue}from"../cell/value-getter.js";import{formatCellValue}from"../cell/value-formatter.js";export function getCellTooltipText(options){if(!options||typeof options!=="object")return"";const{row,rowIndex,column,displayedText,isOverflowing,locale,context,api}=options;if(!column||typeof column.field!=="string")return"";const tooltipField=typeof column.tooltipField==="string"&&column.tooltipField.length>0?column.tooltipField:void 0;if(column.tooltipValueGetter||tooltipField){const raw=resolveCellValue({row,rowIndex,colId:tooltipField??column.field,field:tooltipField??column.field,valueGetter:column.tooltipValueGetter??(tooltipField?void 0:column.valueGetter),colDef:column,context,api});return coerceToString(raw)}if(isOverflowing===true){return resolveFormattedText(row,rowIndex,column,locale,displayedText,context,api)}return""}function resolveFormattedText(row,rowIndex,column,locale,displayedText,context,api){if(typeof displayedText==="string"&&displayedText.length>0)return displayedText;const raw=resolveCellValue({row,rowIndex,colId:column.field,field:column.field,valueGetter:column.valueGetter,colDef:column,context,api});if(column.valueFormatter){return formatCellValue({value:raw,row,rowIndex,colId:column.field,valueFormatter:column.valueFormatter,locale:locale??"en",colDef:column,context,api})}return coerceToString(raw)}function coerceToString(value){if(value===null||value===void 0)return"";if(typeof value==="string")return value;return String(value)}

package/dist/collection/components/grid/core/chart-link/chart-bridge-types-probe.js

@@ -0,0 +1 @@
+export{};

package/dist/collection/components/grid/core/clipboard/parse.js

@@ -0,0 +1 @@
+export function detectPastedValue(raw){const trimmed=raw.trim();if(trimmed==="")return raw;const lower=trimmed.toLowerCase();if(lower==="true")return true;if(lower==="false")return false;if(/^-?0\d/.test(trimmed))return raw;if(/^-?\d+(\.\d+)?([eE][+-]?\d+)?$/.test(trimmed)){if(significantDigits(trimmed)>15)return raw;const num=Number(trimmed);if(Number.isFinite(num))return num}if(/^-?\d{1,3}(,\d{3})+(\.\d+)?$/.test(trimmed)){const plain=trimmed.replace(/,/g,"");if(significantDigits(plain)>15)return raw;const num=Number(plain);if(Number.isFinite(num))return num}return raw}function significantDigits(numericText){const mantissa=numericText.replace(/^[+-]/,"").split(/[eE]/)[0].replace(".","").replace(/^0+/,"");return mantissa.length}export function parseTsv(text){if(text==="")return[];const src=text.endsWith("\r\n")?text.slice(0,-2):text.endsWith("\n")||text.endsWith("\r")?text.slice(0,-1):text;if(src==="")return[];const rows=[];let row=[];let cell="";let i=0;const n=src.length;while(i<n){const ch=src[i];if(cell===""&&ch==='"'){i++;let closed=false;while(i<n){const q=src[i];if(q==='"'){if(src[i+1]==='"'){cell+='"';i+=2;continue}i++;closed=true;break}cell+=q;i++}if(!closed){}continue}if(ch==="	"){row.push(cell);cell="";i++;continue}if(ch==="\n"||ch==="\r"){row.push(cell);rows.push(row);row=[];cell="";i+=ch==="\r"&&src[i+1]==="\n"?2:1;continue}cell+=ch;i++}row.push(cell);rows.push(row);return rows}

package/dist/collection/components/grid/core/clipboard/paste-plan.js

@@ -0,0 +1 @@
+import{readOwnFieldPath}from"../cell/value-getter.js";export function planPaste(matrix,top,left,ctx){const changes=[];let applied=0;let skipped=0;let displayRow=top;for(const line of matrix){while(displayRow<ctx.rowCount&&ctx.dataRowAt(displayRow)===null)displayRow++;if(displayRow>=ctx.rowCount){skipped+=line.length;continue}const row=ctx.dataRowAt(displayRow);const proto=Object.getPrototypeOf(row);const writableRow=proto===Object.prototype||proto===null;for(let j=0;j<line.length;j++){const col=ctx.colAt(left+j);if(!writableRow||col===void 0||col.editable!==true||col.computed){skipped++;continue}let value;try{value=ctx.coerce(line[j],left+j,row)}catch{skipped++;continue}applied++;const oldValue=readOwnFieldPath(row,col.field);if(!Object.is(oldValue,value)){changes.push({displayRow,colIndex:left+j,field:col.field,row,oldValue,newValue:value})}}displayRow++}return{changes,applied,skipped}}

package/dist/collection/components/grid/core/clipboard/serialize.js

@@ -0,0 +1 @@
+import{neutralizeSpreadsheetText}from"../spreadsheet-text.js";export function escapeTsvCell(raw,options={}){const text=neutralizeSpreadsheetText(raw,options);if(!/[\t\n\r"]/.test(text))return text;return`"${text.replace(/"/g,'""')}"`}export function serializeBoundsToTsv(bounds,cellText,includeRow=()=>true,options={}){const lines=[];for(let row=bounds.top;row<=bounds.bottom;row++){if(!includeRow(row))continue;const cells=[];for(let col=bounds.left;col<=bounds.right;col++){cells.push(escapeTsvCell(cellText(row,col),options))}lines.push(cells.join("	"))}return lines.join("\n")}export function serializeManyBoundsToTsv(list,cellText,includeRow=()=>true,options={}){const blocks=list.map(bounds=>serializeBoundsToTsv(bounds,cellText,includeRow,options)).filter(block=>block!=="");return blocks.join("\n")}

package/dist/collection/components/grid/core/collab-css.js

@@ -0,0 +1 @@
+const HEX=/^#(?:[0-9a-f]{3,4}|[0-9a-f]{6}|[0-9a-f]{8})$/i;const FUNC=/^(?:rgb|rgba|hsl|hsla)\(\s*[0-9.,%\s/+-]+\)$/i;const NAMED=new Set(["black","white","gray","grey","silver","red","green","blue","yellow","orange","purple","pink","brown","cyan","magenta","lime","teal","navy","maroon","olive","aqua","fuchsia","indigo","violet","gold","coral","salmon","crimson","turquoise","tan","beige","transparent"]);export const DEFAULT_PRESENCE_COLOR="#94a3b8";export function sanitizeCssColor(value,fallback=DEFAULT_PRESENCE_COLOR){if(typeof value!=="string")return fallback;const v=value.trim();if(v.length===0||v.length>32)return fallback;if(HEX.test(v))return v;if(NAMED.has(v.toLowerCase()))return v;if(FUNC.test(v))return v;return fallback}

package/dist/collection/components/grid/core/collab-loader.js

@@ -0,0 +1 @@
+export function gridCollabChunkSource(){return null}

package/dist/collection/components/grid/core/collab-mentions.js

@@ -0,0 +1 @@
+const MENTION=/(^|[\s([{])@([\p{L}\p{N}_][\p{L}\p{N}_.-]*)/gu;const trimName=raw=>raw.replace(/[.]+$/,"");export function splitMentions(text){const out=[];let cursor=0;MENTION.lastIndex=0;for(let m=MENTION.exec(text);m!==null;m=MENTION.exec(text)){const name=trimName(m[2]);if(name.length===0)continue;const mentionStart=m.index+m[1].length;const mentionEnd=mentionStart+1+name.length;if(mentionStart>cursor)out.push({kind:"text",text:text.slice(cursor,mentionStart)});out.push({kind:"mention",text:text.slice(mentionStart,mentionEnd),name});cursor=mentionEnd;MENTION.lastIndex=mentionEnd}if(cursor<text.length)out.push({kind:"text",text:text.slice(cursor)});if(out.length===0)out.push({kind:"text",text});return out}export function mentionedNames(text){const seen=new Set;const out=[];for(const seg of splitMentions(text)){if(seg.kind!=="mention"||seg.name===void 0)continue;const key=seg.name.toLowerCase();if(seen.has(key))continue;seen.add(key);out.push(seg.name)}return out}export function mentionsUser(text,userName){if(userName===void 0||userName.trim()==="")return false;const target=userName.trim().toLowerCase();return mentionedNames(text).some(n=>n.toLowerCase()===target)}

package/dist/collection/components/grid/core/collab-types.js

@@ -0,0 +1 @@
+export{};

package/dist/collection/components/grid/core/column/column-auto-size.js

@@ -0,0 +1 @@
+export function measureAutoSizeWidth(input,opts={}){const DEFAULT_PADDING=16;const DEFAULT_FONT="14px sans-serif";let warnedThisCall=false;function warnAutoSize(reason){if(warnedThisCall)return;warnedThisCall=true;console.warn(`[Syidax] sy-grid: column-auto-size measureAutoSizeWidth ${reason}`)}let headerText;if(typeof input.headerText==="string"){headerText=input.headerText}else if(input.headerText===void 0||input.headerText===null){headerText=""}else{warnAutoSize(`received non-string headerText (${typeof input.headerText}); coerced to "".`);headerText=""}let cellTexts;if(Array.isArray(input.cellTexts)){cellTexts=input.cellTexts.map(entry=>typeof entry==="string"?entry:String(entry??""))}else if(input.cellTexts===void 0||input.cellTexts===null){cellTexts=[]}else{warnAutoSize(`received non-array cellTexts (${typeof input.cellTexts}); coerced to [].`);cellTexts=[]}let padding;const rawPadding=opts.padding;if(rawPadding===void 0){padding=DEFAULT_PADDING}else if(typeof rawPadding==="number"&&Number.isFinite(rawPadding)&&rawPadding>=0){padding=rawPadding}else{warnAutoSize(`received non-finite/negative padding (${String(rawPadding)}); using default ${DEFAULT_PADDING}.`);padding=DEFAULT_PADDING}const font=typeof opts.font==="string"&&opts.font.length>0?opts.font:DEFAULT_FONT;void font;function isFinitePositive(n){return typeof n==="number"&&Number.isFinite(n)&&n>0}function isFiniteNonNegative(n){return typeof n==="number"&&Number.isFinite(n)&&n>=0}let effectiveMin=0;if(isFiniteNonNegative(opts.minWidth)){effectiveMin=opts.minWidth}else if(isFiniteNonNegative(input.colMin)){effectiveMin=input.colMin}let effectiveMax=Number.POSITIVE_INFINITY;if(isFinitePositive(opts.maxWidth)){effectiveMax=opts.maxWidth}else if(isFinitePositive(input.colMax)){effectiveMax=input.colMax}const rawMeasureText=input.measureText;let safeMeasure;if(typeof rawMeasureText==="function"){safeMeasure=text=>{try{const w=rawMeasureText(text);if(typeof w==="number"&&Number.isFinite(w)&&w>=0)return w;warnAutoSize(`measureText returned non-finite/negative value; treating as 0.`);return 0}catch{warnAutoSize(`measureText threw on input; treating as 0.`);return 0}}}else{warnAutoSize(`received missing/non-function measureText; every measurement falls back to 0.`);safeMeasure=()=>0}let measuredWidth=safeMeasure(headerText);for(let i=0;i<cellTexts.length;i++){const w=safeMeasure(cellTexts[i]);if(w>measuredWidth)measuredWidth=w}const paddedWidth=measuredWidth+padding;let finalWidth=paddedWidth;if(effectiveMin<=effectiveMax){if(finalWidth<effectiveMin)finalWidth=effectiveMin;if(finalWidth>effectiveMax)finalWidth=effectiveMax}const wasClamped=paddedWidth!==finalWidth;return{measuredWidth,paddedWidth,finalWidth,wasClamped}}

package/dist/collection/components/grid/core/column/column-groups.js

@@ -0,0 +1 @@
+export function isColumnGroupDef(def){return Array.isArray(def.children)}export function flattenColumnDefs(defs){const out=[];const visit=nodes=>{for(const node of nodes){if(node===null||node===void 0)continue;if(isColumnGroupDef(node)){visit(node.children)}else{out.push(node)}}};visit(defs);return out}export function groupHasToggle(group){for(const child of group.children){if(child===null||child===void 0)continue;const show=child.columnGroupShow;if(show==="open"||show==="closed")return true}return false}export function visibleGroupLeaves(defs,collapsedGroupIds){const out=[];const visit=(nodes,parentOpen,path)=>{nodes.forEach((node,index)=>{if(node===null||node===void 0)return;const show=node.columnGroupShow;if(parentOpen!==null){if(show==="open"&&!parentOpen)return;if(show==="closed"&&parentOpen)return}const nodePath=path===""?String(index):`${path}.${index}`;if(isColumnGroupDef(node)){const id=node.groupId??nodePath;visit(node.children,!collapsedGroupIds.has(id),nodePath);return}out.push(node)})};visit(defs,null,"");return out}export function columnGroupDepth(defs){let depth=0;const visit=(nodes,level)=>{for(const node of nodes){if(node===null||node===void 0||!isColumnGroupDef(node))continue;if(level+1>depth)depth=level+1;visit(node.children,level+1)}};visit(defs,0);return depth}export function computeHeaderGroupRows(defs,effectiveLeafFields,collapsedGroupIds){const depth=columnGroupDepth(defs);if(depth===0)return[];const ancestry=new Map;const visit=(nodes,chain,path)=>{nodes.forEach((node,index)=>{if(node===null||node===void 0)return;const nodePath=path===""?String(index):`${path}.${index}`;if(isColumnGroupDef(node)){visit(node.children,[...chain,{ref:node,id:node.groupId??nodePath}],nodePath);return}const field=node.field;if(typeof field!=="string"||field===""||ancestry.has(field))return;ancestry.set(field,chain)})};visit(defs,[],"");const rows=[];for(let level=0;level<depth;level++){const row=[];let current=null;let currentKey=null;for(const field of effectiveLeafFields){const ancestor=ancestry.get(field)?.[level];const key=ancestor?`g:${ancestor.id}`:"null";if(current!==null&&key===currentKey){current.leaves.push(field);continue}current=ancestor?{label:ancestor.ref.headerName,leaves:[field],groupId:ancestor.id,collapsible:groupHasToggle(ancestor.ref),open:!(collapsedGroupIds?.has(ancestor.id)??false)}:{label:null,leaves:[field]};currentKey=key;row.push(current)}rows.push(row)}return rows}

package/dist/collection/components/grid/core/column/column-pin.js

@@ -0,0 +1 @@
+export const DEFAULT_PINNED_COLUMN_WIDTH=150;export function effectivePinSide(col,overrides){const field=typeof col.field==="string"?col.field:"";if(field!==""&&overrides&&overrides.has(field)){const side=overrides.get(field);return side==="left"||side==="right"?side:null}return col.pinned==="left"||col.pinned==="right"?col.pinned:null}export function partitionColumnsByPin(cols,overrides){const left=[];const middle=[];const right=[];for(const col of cols){const side=effectivePinSide(col,overrides);if(side==="left"){left.push(col)}else if(side==="right"){right.push(col)}else{middle.push(col)}}return{left,middle,right}}export function applyColumnPinning(cols,overrides){const partition=partitionColumnsByPin(cols,overrides);return[...partition.left,...partition.middle,...partition.right]}export function computePinnedOffsets(pinnedCols,side,widthOf,baseOffset){const out=new Map;const widthAt=col=>{const width=widthOf(col);return typeof width==="number"&&Number.isFinite(width)&&width>0?width:DEFAULT_PINNED_COLUMN_WIDTH};if(side==="left"){let offset2=baseOffset;for(const col of pinnedCols){if(typeof col.field==="string"&&col.field!=="")out.set(col.field,offset2);offset2+=widthAt(col)}return out}let offset=baseOffset;for(let i=pinnedCols.length-1;i>=0;i--){const col=pinnedCols[i];if(typeof col.field==="string"&&col.field!=="")out.set(col.field,offset);offset+=widthAt(col)}return out}

package/dist/collection/components/grid/core/column/column-reorder.js

@@ -0,0 +1 @@
+export function createColumnReorderController(opts={}){function resolveNow(input){return typeof input==="function"?input:()=>Date.now()}const now=resolveNow(opts.now);void now;let active=null;const startedListeners=new Set;const movedListeners=new Set;const committedListeners=new Set;const cancelledListeners=new Set;function warnReorder(callerName,reason){console.warn(`[Syidax] sy-grid: column-reorder ${callerName} ${reason}`)}function clampIndex(value,length){let i=Math.trunc(value);if(i<0)i=0;if(i>length-1)i=length-1;return i}function isFiniteNumber(input){return typeof input==="number"&&Number.isFinite(input)}function reorderArray(source,from,to){const out=source.slice();const[picked]=out.splice(from,1);out.splice(to,0,picked);return out}function emitStarted(event){const snapshot=Array.from(startedListeners);for(let i=0;i<snapshot.length;i++){try{snapshot[i](event)}catch{warnReorder("emit","subscriber on 'started' threw; continuing.")}}}function emitMoved(event){const snapshot=Array.from(movedListeners);for(let i=0;i<snapshot.length;i++){try{snapshot[i](event)}catch{warnReorder("emit","subscriber on 'moved' threw; continuing.")}}}function emitCommitted(event){const snapshot=Array.from(committedListeners);for(let i=0;i<snapshot.length;i++){try{snapshot[i](event)}catch{warnReorder("emit","subscriber on 'committed' threw; continuing.")}}}function emitCancelled(event){const snapshot=Array.from(cancelledListeners);for(let i=0;i<snapshot.length;i++){try{snapshot[i](event)}catch{warnReorder("emit","subscriber on 'cancelled' threw; continuing.")}}}function start(input){if(!Array.isArray(input.columnIds)){warnReorder("start","received non-array columnIds; ignored.");return}if(input.columnIds.length===0){warnReorder("start","received empty columnIds; ignored.");return}const snapshot=input.columnIds.slice();const originIndex=snapshot.indexOf(input.colId);if(originIndex===-1){warnReorder("start","colId not found in columnIds; ignored.");return}active={colId:input.colId,originIndex,currentIndex:originIndex,columnIds:snapshot};emitStarted({kind:"started",colId:input.colId,originIndex})}function move(input){if(active===null){warnReorder("move","called with no active drag; ignored.");return null}if(!isFiniteNumber(input.targetIndex)){warnReorder("move","received non-finite targetIndex; ignored.");return null}const clamped=clampIndex(input.targetIndex,active.columnIds.length);const from=active.currentIndex;if(clamped===from)return null;active.currentIndex=clamped;emitMoved({kind:"moved",colId:active.colId,fromIndex:from,toIndex:clamped});return{fromIndex:from,toIndex:clamped}}function commit(){if(active===null)return null;const colId=active.colId;const originIndex=active.originIndex;const finalIndex=active.currentIndex;const orderBefore=active.columnIds;const orderAfter=finalIndex===originIndex?orderBefore.slice():reorderArray(orderBefore,originIndex,finalIndex);active=null;emitCommitted({kind:"committed",colId,originIndex,finalIndex,orderBefore,orderAfter});return{colId,originIndex,finalIndex,orderBefore,orderAfter}}function cancel(){if(active===null)return null;const result={colId:active.colId,originIndex:active.originIndex};const colId=active.colId;const originIndex=active.originIndex;active=null;emitCancelled({kind:"cancelled",colId,originIndex});return result}function isActive(){return active!==null}function getActive(){if(active===null)return null;return{draggedColId:active.colId,originIndex:active.originIndex,currentIndex:active.currentIndex,columnIdsAtStart:active.columnIds}}function subscribe(channel,listener){if(typeof listener!=="function"){warnReorder("subscribe","listener is not a function; ignored.");return()=>void 0}if(channel==="started"){const set=startedListeners;set.add(listener);return()=>{set.delete(listener)}}if(channel==="moved"){const set=movedListeners;set.add(listener);return()=>{set.delete(listener)}}if(channel==="committed"){const set=committedListeners;set.add(listener);return()=>{set.delete(listener)}}if(channel==="cancelled"){const set=cancelledListeners;set.add(listener);return()=>{set.delete(listener)}}warnReorder("subscribe",`unknown channel "${String(channel)}"; ignored.`);return()=>void 0}return{start,move,commit,cancel,isActive,getActive,subscribe}}

package/dist/collection/components/grid/core/column/column-resize.js

@@ -0,0 +1 @@
+export function createColumnResizeController(opts={}){const DEFAULT_MIN_WIDTH=0;const DEFAULT_MAX_WIDTH=Number.POSITIVE_INFINITY;function resolveMinWidth(input){if(typeof input!=="number")return DEFAULT_MIN_WIDTH;if(!Number.isFinite(input))return DEFAULT_MIN_WIDTH;if(input<0)return DEFAULT_MIN_WIDTH;return input}function resolveMaxWidth(input){if(typeof input!=="number")return DEFAULT_MAX_WIDTH;if(Number.isNaN(input))return DEFAULT_MAX_WIDTH;if(input<=0)return DEFAULT_MAX_WIDTH;return input}function resolveNow(input){return typeof input==="function"?input:()=>Date.now()}const minWidth=resolveMinWidth(opts.minWidth);const maxWidth=resolveMaxWidth(opts.maxWidth);const now=resolveNow(opts.now);let active=null;const startedListeners=new Set;const movedListeners=new Set;const committedListeners=new Set;const cancelledListeners=new Set;function warnResize(callerName,reason){console.warn(`[Syidax] sy-grid: column-resize ${callerName} ${reason}`)}function clampWidth(width,lo,hi){let w=width;if(w<lo)w=lo;if(w>hi)w=hi;return w}function isFiniteNumber(input){return typeof input==="number"&&Number.isFinite(input)}function resolvePerCallMin(input){if(input===void 0)return null;if(typeof input!=="number"||!Number.isFinite(input)||input<0){warnResize("start","received invalid per-call minWidth; using controller default.");return null}return input}function resolvePerCallMax(input){if(input===void 0)return null;if(typeof input!=="number"||!Number.isFinite(input)||input<=0){warnResize("start","received invalid per-call maxWidth; using controller default.");return null}return input}function emitStarted(event){const snapshot=Array.from(startedListeners);for(let i=0;i<snapshot.length;i++){try{snapshot[i](event)}catch{warnResize("emit","subscriber on 'started' threw; continuing.")}}}function emitMoved(event){const snapshot=Array.from(movedListeners);for(let i=0;i<snapshot.length;i++){try{snapshot[i](event)}catch{warnResize("emit","subscriber on 'moved' threw; continuing.")}}}function emitCommitted(event){const snapshot=Array.from(committedListeners);for(let i=0;i<snapshot.length;i++){try{snapshot[i](event)}catch{warnResize("emit","subscriber on 'committed' threw; continuing.")}}}function emitCancelled(event){const snapshot=Array.from(cancelledListeners);for(let i=0;i<snapshot.length;i++){try{snapshot[i](event)}catch{warnResize("emit","subscriber on 'cancelled' threw; continuing.")}}}function start(input){let colId=input.colId;if(colId===null||colId===void 0){warnResize("start",'received null/undefined colId; coerced to "<unknown>".');colId="<unknown>"}let startWidth=input.startWidth;if(!isFiniteNumber(startWidth)||startWidth<0){warnResize("start","received non-finite/negative startWidth; coerced to 0.");startWidth=0}let startX=input.startX;if(!isFiniteNumber(startX)){warnResize("start","received non-finite startX; coerced to 0.");startX=0}const perCallMin=resolvePerCallMin(input.minWidth);const perCallMax=resolvePerCallMax(input.maxWidth);let effectiveMin=perCallMin===null?minWidth:perCallMin;let effectiveMax=perCallMax===null?maxWidth:perCallMax;if(effectiveMin>effectiveMax){warnResize("start","minWidth > maxWidth; dropping both per-call overrides.");effectiveMin=minWidth;effectiveMax=maxWidth}const initialWidth=clampWidth(startWidth,effectiveMin,effectiveMax);active={colId,startWidth:initialWidth,startX,lastX:startX,currentWidth:initialWidth,effectiveMin,effectiveMax,wasClamped:false};emitStarted({colId,startWidth:initialWidth,startX,timestamp:now()})}function move(input){if(active===null){warnResize("move","called with no active drag; ignored.");return null}let x=input.x;if(!isFiniteNumber(x)){warnResize("move","received non-finite x; falling back to lastX.");x=active.lastX}const delta=x-active.startX;const rawWidth=active.startWidth+delta;const nextWidth=clampWidth(rawWidth,active.effectiveMin,active.effectiveMax);const wasClamped=nextWidth!==rawWidth;active.lastX=x;active.currentWidth=nextWidth;active.wasClamped=wasClamped;emitMoved({colId:active.colId,width:nextWidth,x,wasClamped});return{colId:active.colId,width:nextWidth,wasClamped}}function commit(){if(active===null)return null;const result={colId:active.colId,oldWidth:active.startWidth,newWidth:active.currentWidth};const colId=active.colId;active=null;emitCommitted({colId,oldWidth:result.oldWidth,newWidth:result.newWidth,timestamp:now()});return result}function cancel(){if(active===null)return null;const result={colId:active.colId,oldWidth:active.startWidth};const colId=active.colId;active=null;emitCancelled({colId,oldWidth:result.oldWidth,timestamp:now()});return result}function revert(){if(active===null)return null;const result={colId:active.colId,startWidth:active.startWidth};const colId=active.colId;const oldWidth=active.startWidth;active=null;emitCancelled({colId,oldWidth,timestamp:now()});return result}function isActive(){return active!==null}function getActive(){if(active===null)return null;return{colId:active.colId,startWidth:active.startWidth,currentWidth:active.currentWidth,wasClamped:active.wasClamped,effectiveMin:active.effectiveMin,effectiveMax:active.effectiveMax}}function subscribe(channel,listener){if(typeof listener!=="function"){warnResize("subscribe","listener is not a function; ignored.");return()=>void 0}if(channel==="started"){const set=startedListeners;set.add(listener);return()=>{set.delete(listener)}}if(channel==="moved"){const set=movedListeners;set.add(listener);return()=>{set.delete(listener)}}if(channel==="committed"){const set=committedListeners;set.add(listener);return()=>{set.delete(listener)}}if(channel==="cancelled"){const set=cancelledListeners;set.add(listener);return()=>{set.delete(listener)}}warnResize("subscribe",`unknown channel "${String(channel)}"; ignored.`);return()=>void 0}return{start,move,commit,cancel,revert,isActive,getActive,subscribe}}

package/dist/collection/components/grid/core/column/column-sort.js

@@ -0,0 +1 @@
+export function createColumnSortController(){function toAriaSort(direction){if(direction==="asc")return"ascending";if(direction==="desc")return"descending";return"none"}function getIndicatorState(fieldOrId,activeSort){if(activeSort!==null&&activeSort.field===fieldOrId){return{direction:activeSort.direction,isActive:true,sortIndex:null,ariaSort:toAriaSort(activeSort.direction)}}return{direction:null,isActive:false,sortIndex:null,ariaSort:"none"}}function getModelIndicatorState(fieldOrId,sortModel){for(let i=0;i<sortModel.length;i++){if(sortModel[i].field===fieldOrId){return{direction:sortModel[i].direction,isActive:true,sortIndex:sortModel.length>1?i+1:null,ariaSort:toAriaSort(sortModel[i].direction)}}}return{direction:null,isActive:false,sortIndex:null,ariaSort:"none"}}function getNextSort(fieldOrId,activeSort){if(activeSort===null){return{field:fieldOrId,direction:"asc"}}if(activeSort.field!==fieldOrId){return{field:fieldOrId,direction:"asc"}}if(activeSort.direction==="asc"){return{field:fieldOrId,direction:"desc"}}return null}function ariaLabel(direction,label,sortIndex,totalKeys){const priority=typeof sortIndex==="number"&&typeof totalKeys==="number"&&totalKeys>1?`, sort priority ${sortIndex} of ${totalKeys}`:"";if(direction===null){return`Sort by ${label}`}if(direction==="asc"){return`Sorted ascending by ${label}${priority}, click to sort descending`}return`Sorted descending by ${label}${priority}, click to unsort`}return{getIndicatorState,getModelIndicatorState,getNextSort,ariaLabel}}

package/dist/collection/components/grid/core/column/column-state.js

@@ -0,0 +1 @@
+export function computeColumnState(input){function resolveFieldOrder(fields,columnOrder){if(columnOrder===null){return fields.slice()}const fieldSet=new Set(fields);const out=[];for(let i=0;i<columnOrder.length;i++){const f=columnOrder[i];if(fieldSet.has(f)){out.push(f);fieldSet.delete(f)}}for(const remaining of fieldSet){out.push(remaining)}return out}function buildOrderIndex(fields,columnOrder){if(columnOrder===null)return null;const fieldSet=new Set(fields);const map=new Map;let compactIndex=0;for(let i=0;i<columnOrder.length;i++){const field=columnOrder[i];if(!fieldSet.has(field)||map.has(field))continue;map.set(field,compactIndex);compactIndex+=1}return map}function resolveSortModel(sortModel2,activeSort){if(sortModel2!==void 0)return sortModel2;return activeSort===null?[]:[activeSort]}function buildEntry(field,columnWidths,orderIndex2,columnHidden,sortModel2,pinnedSides){const width=columnWidths.has(field)?columnWidths.get(field):null;const order=orderIndex2!==null?orderIndex2.has(field)?orderIndex2.get(field):null:null;const hidden=columnHidden.has(field);let sortIndex=null;for(let i=0;i<sortModel2.length;i++){if(sortModel2[i].field===field){sortIndex=i;break}}const isSorted=sortIndex!==null;const sortDirection=isSorted?sortModel2[sortIndex].direction:null;const pinned=pinnedSides!==void 0?pinnedSides.get(field)??null:null;return{field,width,order,hidden,sortDirection,isSorted,sortIndex,pinned}}const orderedFields=resolveFieldOrder(input.fields,input.columnOrder);const orderIndex=buildOrderIndex(input.fields,input.columnOrder);const sortModel=resolveSortModel(input.sortModel,input.activeSort);const entries=[];for(let i=0;i<orderedFields.length;i++){entries.push(buildEntry(orderedFields[i],input.columnWidths,orderIndex,input.columnHidden,sortModel,input.pinnedSides))}return entries}export function computeApplyColumnState(state,opts){function buildWidths(entries){const map=new Map;for(let i=0;i<entries.length;i++){const e=entries[i];map.set(e.field,e.width)}return map}function buildVisibility(entries){const map=new Map;for(let i=0;i<entries.length;i++){map.set(entries[i].field,entries[i].hidden)}return map}function buildOrder(entries,applyOrder){if(!applyOrder)return null;const ordered=[];const unordered=[];for(let i=0;i<entries.length;i++){const e=entries[i];if(e.order!==null){ordered.push({field:e.field,order:e.order})}else{unordered.push(e.field)}}ordered.sort((a,b)=>a.order-b.order);return[...ordered.map(o=>o.field),...unordered]}function buildSortModel(entries){const sorted=[];const seen=new Set;for(let i=0;i<entries.length;i++){const e=entries[i];if(!e.isSorted||e.sortDirection===null||seen.has(e.field))continue;seen.add(e.field);sorted.push({field:e.field,direction:e.sortDirection,sortIndex:typeof e.sortIndex==="number"&&Number.isFinite(e.sortIndex)?e.sortIndex:Number.POSITIVE_INFINITY,position:i})}sorted.sort((a,b)=>a.sortIndex-b.sortIndex||a.position-b.position);return sorted.map(s=>({field:s.field,direction:s.direction}))}function buildPinned(entries){const map=new Map;for(let i=0;i<entries.length;i++){const e=entries[i];if(!("pinned"in e)||e.pinned===void 0)continue;map.set(e.field,e.pinned==="left"||e.pinned==="right"?e.pinned:null)}return map}const sortModel=buildSortModel(state);return{widths:buildWidths(state),visibility:buildVisibility(state),order:buildOrder(state,opts?.applyOrder),activeSort:sortModel.length>0?sortModel[0]:null,sortModel,pinned:buildPinned(state)}}

package/dist/collection/components/grid/core/column/column-visibility.js

@@ -0,0 +1 @@
+export function createColumnVisibilityController(opts={}){function resolveNow(input){return typeof input==="function"?input:()=>Date.now()}const now=resolveNow(opts.now);void now;const hidden=new Set;const changedListeners=new Set;const resetListeners=new Set;function warnVisibility(callerName,reason){console.warn(`[Syidax] sy-grid: column-visibility ${callerName} ${reason}`)}function isLikelyValidColId(input){return typeof input==="string"&&input.length>0}function snapshotHidden(){return new Set(hidden)}function emitChanged(event){const snapshot=Array.from(changedListeners);for(let i=0;i<snapshot.length;i++){try{snapshot[i](event)}catch{warnVisibility("emit","subscriber on 'changed' threw; continuing.")}}}function emitReset(event){const snapshot=Array.from(resetListeners);for(let i=0;i<snapshot.length;i++){try{snapshot[i](event)}catch{warnVisibility("emit","subscriber on 'reset' threw; continuing.")}}}function hide(colId){if(!isLikelyValidColId(colId)){warnVisibility("hide",`received non-string colId "${String(colId)}"; ignored.`);return}if(hidden.has(colId))return;hidden.add(colId);emitChanged({kind:"changed",colId,hidden:true,hiddenIds:snapshotHidden()})}function show(colId){if(!isLikelyValidColId(colId)){warnVisibility("show",`received non-string colId "${String(colId)}"; ignored.`);return}if(!hidden.has(colId))return;hidden.delete(colId);emitChanged({kind:"changed",colId,hidden:false,hiddenIds:snapshotHidden()})}function toggle(colId){if(!isLikelyValidColId(colId)){warnVisibility("toggle",`received non-string colId "${String(colId)}"; ignored.`);return hidden.has(colId)}const wasHidden=hidden.has(colId);if(wasHidden){hidden.delete(colId);emitChanged({kind:"changed",colId,hidden:false,hiddenIds:snapshotHidden()});return false}hidden.add(colId);emitChanged({kind:"changed",colId,hidden:true,hiddenIds:snapshotHidden()});return true}function setHidden(colIds){if(!Array.isArray(colIds)){warnVisibility("setHidden","received non-array input; ignored.");return}const nextSet=new Set;let skipped=0;for(let i=0;i<colIds.length;i++){const id=colIds[i];if(!isLikelyValidColId(id)){skipped++;continue}nextSet.add(id)}if(skipped>0){warnVisibility("setHidden",`skipped ${skipped} non-string entr${skipped===1?"y":"ies"} in input.`)}const newlyHidden=[];for(const id of nextSet){if(!hidden.has(id))newlyHidden.push(id)}const newlyShown=[];for(const id of hidden){if(!nextSet.has(id))newlyShown.push(id)}if(newlyHidden.length===0&&newlyShown.length===0){return}for(let i=0;i<newlyHidden.length;i++){const id=newlyHidden[i];hidden.add(id);emitChanged({kind:"changed",colId:id,hidden:true,hiddenIds:snapshotHidden()})}for(let i=0;i<newlyShown.length;i++){const id=newlyShown[i];hidden.delete(id);emitChanged({kind:"changed",colId:id,hidden:false,hiddenIds:snapshotHidden()})}}function reset(){if(hidden.size===0)return;hidden.clear();emitReset({kind:"reset",hiddenIds:snapshotHidden()})}function isHidden(colId){return hidden.has(colId)}function getHidden(){return snapshotHidden()}function subscribe(channel,listener){if(typeof listener!=="function"){warnVisibility("subscribe","listener is not a function; ignored.");return()=>void 0}if(channel==="changed"){const set=changedListeners;set.add(listener);return()=>{set.delete(listener)}}if(channel==="reset"){const set=resetListeners;set.add(listener);return()=>{set.delete(listener)}}warnVisibility("subscribe",`unknown channel "${String(channel)}"; ignored.`);return()=>void 0}return{hide,show,toggle,setHidden,reset,isHidden,getHidden,subscribe}}

package/dist/collection/components/grid/core/column/index.js

@@ -0,0 +1 @@
+export*from"./column-resize.js";export*from"./column-reorder.js";export*from"./column-visibility.js";export*from"./column-auto-size.js";export*from"./column-sort.js";export*from"./column-state.js";

package/dist/collection/components/grid/core/component/async-value-source.js

@@ -0,0 +1 @@
+function linkAbort(controller,parent){if(parent===void 0)return()=>void 0;const onAbort=()=>controller.abort(parent.reason);if(parent.aborted){onAbort();return()=>void 0}parent.addEventListener("abort",onAbort,{once:true});return()=>parent.removeEventListener("abort",onAbort)}export function createGridAsyncValueSource(loader){let state={phase:"idle",generation:0,query:"",values:[]};let active;let generationCounter=0;let destroyed=false;const listeners=new Set;const publish=next=>{state=next;for(const listener of[...listeners]){try{listener(next)}catch{}}};const load=(rawQuery="",options={})=>{const query=String(rawQuery);if(destroyed){return Promise.resolve({status:"aborted",generation:state.generation})}if(active!==void 0&&active.query===query&&active.parentSignal===options.signal){return active.promise}active?.controller.abort(new DOMException("Superseded by a newer value load.","AbortError"));active?.removeParentAbort();const generation=++generationCounter;const controller=new AbortController;const removeParentAbort=linkAbort(controller,options.signal);const promise=Promise.resolve().then(()=>loader({query,signal:controller.signal})).then(rawValues=>{if(destroyed||active?.generation!==generation||controller.signal.aborted){return{status:controller.signal.aborted?"aborted":"stale",generation}}const values=Array.isArray(rawValues)?[...rawValues]:[];publish({phase:"ready",generation,query,values});return{status:"ready",generation,values}},error=>{if(destroyed||active?.generation!==generation||controller.signal.aborted){return{status:controller.signal.aborted?"aborted":"stale",generation}}publish({phase:"error",generation,query,values:state.values,error});return{status:"failed",generation,error}}).finally(()=>{if(active?.generation!==generation)return;active.removeParentAbort();active=void 0});active={generation,query,parentSignal:options.signal,controller,removeParentAbort,promise};publish({phase:"loading",generation,query,values:state.values});return promise};return{load,refresh(options){return load(state.query,options)},snapshot(){return state},subscribe(listener){if(destroyed)return()=>void 0;listeners.add(listener);return()=>listeners.delete(listener)},destroy(){if(destroyed)return;destroyed=true;active?.controller.abort(new DOMException("Value source destroyed.","AbortError"));active?.removeParentAbort();active=void 0;listeners.clear();publish({phase:"destroyed",generation:state.generation,query:state.query,values:[]})}}}

package/dist/collection/components/grid/core/component/component-runtime-chunk.js

@@ -0,0 +1 @@
+import{GridComponentError}from"./contracts.js";import{createGridComponentRegistry}from"./registry.js";import{createGridRendererController}from"./renderer-controller.js";import{createGridEditorAdapter}from"./editor-adapter.js";import{createGridExternalFilterController,createGridFilterAdapter,createGridFloatingFilterAdapter,subscribeGridExternalFilterAvailability}from"./filter-adapter.js";import{createGridRichSelectEditorDefinition}from"./rich-select-editor.js";export*from"./filter-facade-controller.js";export*from"./editor-facade-controller.js";export*from"./editor-validation-presentation.js";export*from"./popup-placement.js";const sharedGlobalRegistry=createGridComponentRegistry();function hasOwn(value,key){return Object.prototype.hasOwnProperty.call(value,key)}function normalizedComponentName(value){return typeof value==="string"&&value.trim().length>0?value.trim():void 0}function hasRequestLocalDefinition(request,name){const local=request.local;if(local===void 0)return false;const group=local[request.kind];return group!==null&&group!==void 0&&typeof group==="object"&&hasOwn(group,name)}function linkAbortSignals(requestSignal,lifecycleSignal){if(requestSignal===void 0||requestSignal===lifecycleSignal){return{signal:requestSignal??lifecycleSignal,release(){}}}const controller=new AbortController;const sources=[requestSignal,lifecycleSignal];const listeners=[];for(const source of sources){if(source.aborted){controller.abort(source.reason);break}const onAbort=()=>controller.abort(source.reason);source.addEventListener("abort",onAbort,{once:true});listeners.push([source,onAbort])}return{signal:controller.signal,release(){for(const[source,listener]of listeners){source.removeEventListener("abort",listener)}listeners.length=0}}}function asGlobalRegistry(){return sharedGlobalRegistry}export function createGridComponentManager(options={}){const local=createGridComponentRegistry();const global=asGlobalRegistry();const lifecycleController=new AbortController;const reportError=options.onError===void 0?void 0:error=>{try{options.onError?.(error)}catch{}};const runtimeOptions={timeoutMs:options.timeoutMs,onError:reportError};const renderer=createGridRendererController({...options.renderer,runtime:runtimeOptions,onError:reportError});const editor=createGridEditorAdapter(runtimeOptions);const filter=createGridFilterAdapter({...runtimeOptions,modelsEqual:options.modelsEqual});const floatingFilter=createGridFloatingFilterAdapter({...runtimeOptions,modelsEqual:options.modelsEqual});let external=null;let disconnected=false;let disconnectTask;let externalRevision=0;let externalTail=Promise.resolve();let externalAvailabilityCleanup;let externalUnavailableSource;function abortedLookupError(kind,name,cause){return new GridComponentError(`${kind} component lookup was aborted because the grid disconnected or the request was cancelled.`,{code:"ABORTED",phase:"lookup",componentKind:kind,componentName:name,retryable:true,cause})}function assertConnected(kind,name){if(!disconnected)return;throw abortedLookupError(kind,normalizedComponentName(name),lifecycleController.signal.reason)}return{renderer,editor,filter,floatingFilter,register(scope,kind,name,definition){assertConnected(kind,name);(scope==="global"?global:local).register(scope,kind,name,definition)},replace(scope,kind,name,definition){assertConnected(kind,name);(scope==="global"?global:local).replace(scope,kind,name,definition)},unregister(scope,kind,name){assertConnected(kind,name);return(scope==="global"?global:local).unregister(scope,kind,name)},list(scope,kind){return(scope==="global"?global:local).list(scope,kind)},async resolve(request){const name=normalizedComponentName(request.name);assertConnected(request.kind,name);const linked=linkAbortSignals(request.signal,lifecycleController.signal);try{if(linked.signal.aborted){throw abortedLookupError(request.kind,name,linked.signal.reason)}const resolveLocally=hasOwn(request,"definition")||name===void 0||hasRequestLocalDefinition(request,name)||local.has("local",request.kind,name);const forwardedRequest={kind:request.kind,name:request.name,local:request.local,signal:linked.signal,...hasOwn(request,"definition")?{definition:request.definition}:{}};const resolved=resolveLocally?await local.resolve(forwardedRequest):await global.resolve(forwardedRequest);if(disconnected||linked.signal.aborted){throw abortedLookupError(request.kind,name,linked.signal.reason)}return resolved}finally{linked.release()}},setExternalFilter(source){if(disconnected)return Promise.resolve(null);if(source!==null&&externalAvailabilityCleanup!==void 0&&Object.is(externalUnavailableSource,source)){return Promise.resolve(null)}externalAvailabilityCleanup?.();externalAvailabilityCleanup=void 0;externalUnavailableSource=void 0;const revision=++externalRevision;const operation=externalTail.then(async()=>{if(disconnected||revision!==externalRevision)return null;const previous=external;external=null;await previous?.destroy();if(disconnected||revision!==externalRevision||source===null){return null}let next;try{next=createGridExternalFilterController(source,{timeoutMs:options.timeoutMs,onError:reportError})}catch(cause){if(cause instanceof GridComponentError&&cause.code==="INVALID_INSTANCE"){reportError?.(cause);externalUnavailableSource=source;externalAvailabilityCleanup=subscribeGridExternalFilterAvailability(source,()=>{externalAvailabilityCleanup=void 0;externalUnavailableSource=void 0;if(disconnected||revision!==externalRevision){return}try{options.onExternalFilterAvailable?.()}catch{}});return null}throw cause}external=next;return next});externalTail=operation.then(()=>void 0,()=>void 0);return operation},getExternalFilter(){return external},createRichSelectEditor(richSelectOptions){return createGridRichSelectEditorDefinition(richSelectOptions)},disconnect(){if(disconnectTask!==void 0)return disconnectTask;disconnected=true;++externalRevision;externalAvailabilityCleanup?.();externalAvailabilityCleanup=void 0;externalUnavailableSource=void 0;lifecycleController.abort(new Error("Grid component manager disconnected."));local.clear();const componentCleanup=Promise.all([renderer.dispose(),editor.runtime.dispose(),filter.disconnect(),floatingFilter.disconnect()]);const externalCleanup=(async()=>{await externalTail;const previousExternal=external;external=null;await previousExternal?.destroy()})();disconnectTask=Promise.all([componentCleanup,externalCleanup]).then(()=>void 0);return disconnectTask}}}

package/dist/collection/components/grid/core/component/contracts.js

@@ -0,0 +1 @@
+export const GRID_COMPONENT_KINDS=["renderer","editor","filter","floatingFilter"];export const GRID_COMPONENT_ERROR_CODES=["INVALID_NAME","DUPLICATE_COMPONENT","COMPONENT_NOT_FOUND","LAZY_LOAD_FAILED","LAZY_INVALID_DEFINITION","CREATE_FAILED","INIT_FAILED","GUI_FAILED","REFRESH_FAILED","AFTER_ATTACH_FAILED","AFTER_DETACH_FAILED","VALUE_FAILED","VALIDATION_FAILED","COMMIT_FAILED","MODEL_FAILED","FOCUS_FAILED","POPUP_FAILED","FRAMEWORK_FAILED","DESTROY_FAILED","TIMEOUT","ABORTED","INVALID_INSTANCE"];export class GridComponentError extends Error{code;phase;componentKind;componentName;mountKey;generation;retryable;cause;constructor(message,details){super(message);this.name="GridComponentError";this.code=details.code;this.phase=details.phase;this.componentKind=details.componentKind;this.componentName=details.componentName;this.mountKey=details.mountKey;this.generation=details.generation;this.retryable=details.retryable;this.cause=details.cause}}

package/dist/collection/components/grid/core/component/editor-adapter.js

@@ -0,0 +1 @@
+import{GridComponentError}from"./contracts.js";import{createGridComponentRuntime}from"./runtime.js";const DEFAULT_EDITOR_STEP_TIMEOUT_MS=5e3;function editorError(code,phase,key,generation,componentName,cause){if(cause instanceof GridComponentError)return cause;return new GridComponentError(`Editor "${componentName??key}" failed during ${phase}.`,{code,phase,componentKind:"editor",componentName,mountKey:key,generation,retryable:code!=="ABORTED",cause})}function safeReport(onError,error){try{onError?.(error)}catch{}}function runEditorStep(operation,options){return new Promise((resolve,reject)=>{let settled=false;const settle=callback=>{if(settled)return;settled=true;clearTimeout(timer);options.signal.removeEventListener("abort",onAbort);callback()};const onAbort=()=>settle(()=>reject(editorError("ABORTED",options.phase,options.key,options.generation,options.componentName,options.signal.reason)));const timer=setTimeout(()=>settle(()=>reject(editorError("TIMEOUT",options.phase,options.key,options.generation,options.componentName,new Error(`Timed out after ${options.timeoutMs}ms.`)))),options.timeoutMs);if(options.signal.aborted){onAbort();return}options.signal.addEventListener("abort",onAbort,{once:true});Promise.resolve().then(()=>{if(settled||options.signal.aborted){if(!settled)onAbort();return void 0}return operation()}).then(value=>settle(()=>resolve(value)),cause=>settle(()=>reject(editorError(options.failureCode,options.phase,options.key,options.generation,options.componentName,cause))))})}function normalizeValidationErrors(value){if(!Array.isArray(value))return[];const normalized=[];for(let index=0;index<value.length;index+=1){let candidate;try{candidate=value[index]}catch{continue}if(candidate===null||typeof candidate!=="object")continue;let message;try{message=candidate.message}catch{continue}if(typeof message!=="string"||message.trim().length===0){continue}let code;try{code=candidate.code}catch{code=void 0}normalized.push(typeof code==="string"?{message,code}:{message})}return normalized}export function createGridEditorAdapter(options={}){const timeoutMs=options.timeoutMs??DEFAULT_EDITOR_STEP_TIMEOUT_MS;const runtime=createGridComponentRuntime({...options,kind:"editor"});const stopOperations=new Map;const destroyIfCurrent=(key,generation)=>{const current=runtime.lookup(key);if(current.status!=="mounted"||current.generation!==generation){return Promise.resolve(false)}return runtime.destroy(key)};const start=async request=>{const mounted=await runtime.mount({key:request.key,componentName:request.componentName,definition:request.definition,params:request.params});if(mounted.status!=="mounted")return mounted;const lookup=runtime.lookup(request.key);if(lookup.status!=="mounted"||lookup.generation!==mounted.generation){return{status:"stale",key:request.key,generation:mounted.generation}}const stepOptions={key:request.key,generation:mounted.generation,componentName:request.componentName,signal:lookup.params.signal,timeoutMs};try{let cancelBeforeHook;try{const candidate=lookup.instance.isCancelBeforeStart;if(candidate!==void 0&&typeof candidate!=="function"){throw new TypeError("Editor isCancelBeforeStart must be a function when provided.")}cancelBeforeHook=candidate}catch(cause){throw editorError("VALIDATION_FAILED","validate",request.key,mounted.generation,request.componentName,cause)}const ownerAfterCancelCapture=runtime.lookup(request.key);if(ownerAfterCancelCapture.status!=="mounted"||ownerAfterCancelCapture.generation!==mounted.generation){return{status:"stale",key:request.key,generation:mounted.generation}}const cancelBefore=cancelBeforeHook===void 0?false:await runEditorStep(()=>cancelBeforeHook.call(lookup.instance),{...stepOptions,phase:"validate",failureCode:"VALIDATION_FAILED"});if(cancelBefore){await destroyIfCurrent(request.key,mounted.generation);return{status:"cancelled-before-start",key:request.key,generation:mounted.generation}}const currentAfterCancel=runtime.lookup(request.key);if(currentAfterCancel.status!=="mounted"||currentAfterCancel.generation!==mounted.generation){return{status:"stale",key:request.key,generation:mounted.generation}}let popup=false;let popupPosition="over";try{const isPopup=mounted.instance.isPopup;if(isPopup!==void 0&&typeof isPopup!=="function"){throw new TypeError("Editor isPopup must be a function when provided.")}let ownerAfterPopupCapture=runtime.lookup(request.key);if(ownerAfterPopupCapture.status!=="mounted"||ownerAfterPopupCapture.generation!==mounted.generation){return{status:"stale",key:request.key,generation:mounted.generation}}popup=isPopup?.call(mounted.instance)===true;ownerAfterPopupCapture=runtime.lookup(request.key);if(ownerAfterPopupCapture.status!=="mounted"||ownerAfterPopupCapture.generation!==mounted.generation){return{status:"stale",key:request.key,generation:mounted.generation}}const getPopupPosition=mounted.instance.getPopupPosition;if(getPopupPosition!==void 0&&typeof getPopupPosition!=="function"){throw new TypeError("Editor getPopupPosition must be a function when provided.")}const ownerAfterPositionCapture=runtime.lookup(request.key);if(ownerAfterPositionCapture.status!=="mounted"||ownerAfterPositionCapture.generation!==mounted.generation){return{status:"stale",key:request.key,generation:mounted.generation}}const position=getPopupPosition?.call(mounted.instance);if(position!==void 0&&position!=="over"&&position!=="under"){throw new TypeError('Editor getPopupPosition must return "over" or "under".')}popupPosition=position??"over";const ownerAfterPopupRead=runtime.lookup(request.key);if(ownerAfterPopupRead.status!=="mounted"||ownerAfterPopupRead.generation!==mounted.generation){return{status:"stale",key:request.key,generation:mounted.generation}}await Promise.resolve();const ownerBeforeStartResult=runtime.lookup(request.key);if(ownerBeforeStartResult.status!=="mounted"||ownerBeforeStartResult.generation!==mounted.generation){return{status:"stale",key:request.key,generation:mounted.generation}}}catch(cause){throw editorError("POPUP_FAILED","popup",request.key,mounted.generation,request.componentName,cause)}return{status:"started",key:request.key,generation:mounted.generation,instance:mounted.instance,gui:mounted.gui,popup,popupPosition}}catch(cause){const error=cause instanceof GridComponentError?cause:editorError("AFTER_ATTACH_FAILED","after-attach",request.key,mounted.generation,request.componentName,cause);await destroyIfCurrent(request.key,mounted.generation);safeReport(options.onError,error);return{status:"failed",key:request.key,generation:mounted.generation,error}}};const afterAttach=async(key,generation)=>{const lookup=runtime.lookup(key);if(lookup.status!=="mounted"||lookup.generation!==generation){return{status:"stale",key,generation}}try{const afterGuiAttached=lookup.instance.afterGuiAttached;if(afterGuiAttached===void 0){return{status:"attached",key,generation}}if(typeof afterGuiAttached!=="function"){throw new TypeError("Editor afterGuiAttached must be a function when provided.")}const ownerAfterCapture=runtime.lookup(key);if(ownerAfterCapture.status!=="mounted"||ownerAfterCapture.generation!==generation){return{status:"stale",key,generation}}await runEditorStep(()=>afterGuiAttached.call(lookup.instance),{key,generation,componentName:void 0,signal:lookup.params.signal,timeoutMs,phase:"after-attach",failureCode:"AFTER_ATTACH_FAILED"});const current=runtime.lookup(key);return current.status==="mounted"&&current.generation===generation?{status:"attached",key,generation}:{status:"stale",key,generation}}catch(cause){const current=runtime.lookup(key);if(current.status!=="mounted"||current.generation!==generation){return{status:"stale",key,generation}}const error=cause instanceof GridComponentError?cause:editorError("AFTER_ATTACH_FAILED","after-attach",key,generation,void 0,cause);await destroyIfCurrent(key,generation);safeReport(options.onError,error);return{status:"failed",key,generation,error}}};const stop=(key,request)=>{const initial=runtime.lookup(key);if(initial.status!=="mounted"){return Promise.resolve({status:"not-mounted",key})}const operationKey=`${key}\0${initial.generation}`;const existing=stopOperations.get(operationKey);if(existing!==void 0)return existing;const operation=(async()=>{const lookup=initial;const{generation,instance,params}=lookup;const stepOptions={key,generation,componentName:void 0,signal:params.signal,timeoutMs};if(request.cancel===true){await destroyIfCurrent(key,generation);return{status:"cancelled",key,generation}}try{const originalValue=params.value;const getValue=instance.getValue;if(typeof getValue!=="function"){throw editorError("VALUE_FAILED","value",key,generation,void 0,new TypeError("Editor getValue must be a function."))}const ownerAfterValueCapture=runtime.lookup(key);if(ownerAfterValueCapture.status!=="mounted"||ownerAfterValueCapture.generation!==generation){return{status:"stale",key,generation}}let value=await runEditorStep(()=>getValue.call(instance),{...stepOptions,phase:"value",failureCode:"VALUE_FAILED"});const ownerAfterValueRead=runtime.lookup(key);if(ownerAfterValueRead.status!=="mounted"||ownerAfterValueRead.generation!==generation){return{status:"stale",key,generation}}let context={key,generation,reason:request.reason,originalValue,params,signal:params.signal};if(request.parseValue!==void 0){value=await runEditorStep(()=>request.parseValue(value,context),{...stepOptions,phase:"value",failureCode:"VALUE_FAILED"})}const validationErrors=[];const getValidationErrors=instance.getValidationErrors;if(getValidationErrors!==void 0&&typeof getValidationErrors!=="function"){throw editorError("VALIDATION_FAILED","validate",key,generation,void 0,new TypeError("Editor getValidationErrors must be a function when provided."))}const ownerAfterValidationCapture=runtime.lookup(key);if(ownerAfterValidationCapture.status!=="mounted"||ownerAfterValidationCapture.generation!==generation){return{status:"stale",key,generation}}if(getValidationErrors!==void 0){validationErrors.push(...normalizeValidationErrors(await runEditorStep(()=>getValidationErrors.call(instance,value),{...stepOptions,phase:"validate",failureCode:"VALIDATION_FAILED"})))}if(request.validate!==void 0){validationErrors.push(...normalizeValidationErrors(await runEditorStep(()=>request.validate(value,context),{...stepOptions,phase:"validate",failureCode:"VALIDATION_FAILED"})))}const ownerAfterValidation=runtime.lookup(key);if(ownerAfterValidation.status!=="mounted"||ownerAfterValidation.generation!==generation||ownerAfterValidation.params.signal.aborted){return{status:"stale",key,generation}}const invalidMode=request.invalidMode??"revert";if(validationErrors.length>0&&invalidMode!=="allow"){if(invalidMode==="revert"){await destroyIfCurrent(key,generation)}return{status:"invalid",key,generation,value,mode:invalidMode,errors:validationErrors}}const cancelAfterHook=instance.isCancelAfterEnd;if(cancelAfterHook!==void 0&&typeof cancelAfterHook!=="function"){throw editorError("VALIDATION_FAILED","validate",key,generation,void 0,new TypeError("Editor isCancelAfterEnd must be a function when provided."))}const ownerAfterCancelCapture=runtime.lookup(key);if(ownerAfterCancelCapture.status!=="mounted"||ownerAfterCancelCapture.generation!==generation){return{status:"stale",key,generation}}const cancelAfter=cancelAfterHook===void 0?false:await runEditorStep(()=>cancelAfterHook.call(instance),{...stepOptions,phase:"validate",failureCode:"VALIDATION_FAILED"});if(cancelAfter){await destroyIfCurrent(key,generation);return{status:"cancelled",key,generation}}context={...context,signal:params.signal};if(request.canCommit!==void 0&&!await runEditorStep(()=>request.canCommit(value,context),{...stepOptions,phase:"validate",failureCode:"VALIDATION_FAILED"})){await destroyIfCurrent(key,generation);return{status:"rejected",key,generation,reason:"policy"}}const current=runtime.lookup(key);if(current.status!=="mounted"||current.generation!==generation){return{status:"stale",key,generation}}if(request.prepareCommit!==void 0){await runEditorStep(()=>request.prepareCommit(value,context),{...stepOptions,phase:"commit",failureCode:"COMMIT_FAILED"})}const beforeCommit=runtime.lookup(key);if(beforeCommit.status!=="mounted"||beforeCommit.generation!==generation||beforeCommit.params.signal.aborted){return{status:"stale",key,generation}}try{request.commit(value,context)}catch(cause){throw editorError("COMMIT_FAILED","commit",key,generation,void 0,cause)}await destroyIfCurrent(key,generation);return{status:"committed",key,generation,value,validationErrors}}catch(cause){const current=runtime.lookup(key);if(current.status!=="mounted"||current.generation!==generation){return{status:"stale",key,generation}}const error=cause instanceof GridComponentError?cause:editorError("COMMIT_FAILED","commit",key,generation,void 0,cause);safeReport(options.onError,error);return{status:"failed",key,generation,error}}})().finally(()=>{if(stopOperations.get(operationKey)===operation){stopOperations.delete(operationKey)}});stopOperations.set(operationKey,operation);return operation};const focus=(key,direction)=>{const lookup=runtime.lookup(key);if(lookup.status!=="mounted")return false;try{const hook=direction==="in"?lookup.instance.focusIn:lookup.instance.focusOut;if(hook!==void 0&&typeof hook!=="function"){throw new TypeError(`Editor focus${direction==="in"?"In":"Out"} must be a function when provided.`)}let owner=runtime.lookup(key);if(owner.status!=="mounted"||owner.generation!==lookup.generation){return false}hook?.call(lookup.instance);owner=runtime.lookup(key);return owner.status==="mounted"&&owner.generation===lookup.generation}catch(cause){safeReport(options.onError,editorError("FOCUS_FAILED","focus",key,lookup.generation,void 0,cause));return false}};return{runtime,start,afterAttach,stop,cancel(key,generation){if(generation!==void 0)return destroyIfCurrent(key,generation);return runtime.destroy(key)},focusIn(key,generation){const lookup=runtime.lookup(key);if(generation!==void 0&&(lookup.status!=="mounted"||lookup.generation!==generation)){return false}return focus(key,"in")},focusOut(key,generation){const lookup=runtime.lookup(key);if(generation!==void 0&&(lookup.status!=="mounted"||lookup.generation!==generation)){return false}return focus(key,"out")}}}

package/dist/collection/components/grid/core/component/editor-facade-controller.js

@@ -0,0 +1 @@
+import{GridComponentError}from"./contracts.js";function linkController(parent){const controller=new AbortController;if(parent===void 0){return{controller,release:()=>void 0}}const onAbort=()=>controller.abort(parent.reason);if(parent.aborted)onAbort();else parent.addEventListener("abort",onAbort,{once:true});return{controller,release(){parent.removeEventListener("abort",onAbort)}}}function isRichSelectDeclaration(value){return typeof value==="object"&&value!==null&&value.type==="rich-select"}function sameRef(left,right){return left.key===right.key&&left.generation===right.generation}function lifecycleError(code,phase,ref,cause){if(cause instanceof GridComponentError)return cause;return new GridComponentError(`Editor "${ref.key}" facade failed during ${phase}.`,{code,phase,componentKind:"editor",mountKey:ref.key,generation:ref.generation,retryable:true,cause})}function lookupError(key,cause){if(cause instanceof GridComponentError)return cause;return new GridComponentError(`Editor "${key}" could not be resolved.`,{code:"COMPONENT_NOT_FOUND",phase:"lookup",componentKind:"editor",mountKey:key,retryable:true,cause})}function isTerminalStop(result){return!(result.status==="failed"||result.status==="invalid"&&result.mode==="block")}function transactionOutcome(result){if(result.status==="committed")return"committed";if(result.status==="failed"||result.status==="not-active"||result.status==="invalid"&&result.mode==="block"){return"retained"}return"cancelled"}function safeReport(callback,error){try{callback?.(error)}catch{}}function stopNotificationError(key,ref,cause){if(cause instanceof GridComponentError)return cause;return new GridComponentError(`Editor "${key}" host stop-result listener failed.`,{code:"FRAMEWORK_FAILED",phase:"framework",componentKind:"editor",mountKey:key,...ref===void 0?{}:{generation:ref.generation},retryable:false,cause})}export function createGridEditorFacadeController(options){const{manager}=options;let active;let pending;let revision=0;let disposed=false;const notifyStopResult=(key,ref,listener,reason,origin,result)=>{if(listener===void 0)return;const outcome=transactionOutcome(result);try{listener({key,ref,reason,origin,result,transactionOutcome:outcome,terminal:outcome!=="retained"})}catch(cause){safeReport(options.onError,stopNotificationError(key,ref,cause))}};const notifyPendingStop=(operation,reason,origin)=>{const result={status:"cancelled-before-start",key:operation.key};if(!operation.stopNotified){operation.stopNotified=true;notifyStopResult(operation.key,void 0,operation.onStopResult,reason,origin,result)}return result};const retirePending=(operation,reason,origin)=>{if(pending===operation)pending=void 0;operation.removeOwnerAbortWatch?.();operation.removeOwnerAbortWatch=void 0;if(!operation.linked.controller.signal.aborted){operation.linked.controller.abort(new Error(`Pending editor stopped by ${reason}.`))}operation.linked.release();return notifyPendingStop(operation,reason,origin)};const currentSession=session=>{if(active!==session)return false;const lookup=manager.editor.runtime.lookup(session.ref.key);return lookup.status==="mounted"&&lookup.generation===session.ref.generation};const focusInSession=session=>{const focused=manager.editor.focusIn(session.ref.key,session.ref.generation);if(focused){session.focusOutCalled=false;session.focusOutResult=false}return focused};const focusOutSession=session=>{if(session.focusOutCalled)return session.focusOutResult;session.focusOutCalled=true;session.focusOutResult=manager.editor.focusOut(session.ref.key,session.ref.generation);return session.focusOutResult};const releaseSessionSignal=session=>{session.removeAbortWatch?.();session.removeAbortWatch=void 0;session.linked.release();if(!session.linked.controller.signal.aborted){session.linked.controller.abort(new Error(`Editor "${session.ref.key}" session ended.`))}};const detachOrphan=async(host,attachment,session,reason)=>{if(host.detach===void 0)return;try{await host.detach(attachment,{ref:session.ref,gui:session.gui,reason,params:session.params})}catch(cause){safeReport(options.onError,lifecycleError("DESTROY_FAILED","destroy",session.ref,cause))}};const detachSession=(session,reason)=>{if(session.detachTask!==void 0)return session.detachTask;if(!session.attached||session.host===void 0){return Promise.resolve()}const host=session.host;const attachment=session.attachment;session.attached=false;session.detachTask=detachOrphan(host,attachment,session,reason);return session.detachTask};const clearTerminalSession=async(session,reason)=>{if(active===session)active=void 0;releaseSessionSignal(session);await detachSession(session,reason)};const stopSession=(session,reason,cancel,origin="controller",restoreFocusOnRetain=true)=>{const shouldCancel=cancel??(reason==="escape"||reason==="disconnect");if(session.stopTask!==void 0){if(shouldCancel&&!session.stopCancelRequested&&active===session){session.stopCancelRequested=true;session.stopOverride={reason,origin,cancelTask:manager.editor.cancel(session.ref.key,session.ref.generation)}}return session.stopTask}session.stopCancelRequested=shouldCancel;let resolveTask;let rejectTask;const task=new Promise((resolve,reject)=>{resolveTask=resolve;rejectTask=reject});session.stopTask=task;const operation=(async()=>{focusOutSession(session);const request=session.commitOptions;let result=await manager.editor.stop(session.ref.key,{reason,cancel:shouldCancel,invalidMode:request.invalidMode,parseValue:request.parseValue,validate:request.validate,canCommit:request.canCommit,prepareCommit:request.prepareCommit,commit:(value,context)=>{if(request.commitPrepared(value,context)===false){throw new GridComponentError(`Editor "${session.ref.key}" host rejected the prepared commit.`,{code:"COMMIT_FAILED",phase:"commit",componentKind:"editor",mountKey:session.ref.key,generation:session.ref.generation,retryable:true,cause:new Error("The host commit choke point returned false.")})}}});let terminalReason=reason;let terminalOrigin=origin;const override=session.stopOverride;if(override!==void 0){await override.cancelTask;if(result.status!=="committed"){result={status:"cancelled",key:session.ref.key,generation:session.ref.generation};terminalReason=override.reason;terminalOrigin=override.origin}}if(restoreFocusOnRetain&&!isTerminalStop(result)&&active===session){focusInSession(session)}const cleanup=isTerminalStop(result)?clearTerminalSession(session,terminalReason):void 0;notifyStopResult(session.ref.key,session.ref,session.onStopResult,terminalReason,terminalOrigin,result);if(isTerminalStop(result)){await cleanup}return result})();void operation.then(result=>{if(session.stopTask===task)session.stopTask=void 0;resolveTask(result)},cause=>{if(session.stopTask===task)session.stopTask=void 0;rejectTask(cause)});return task};const forceCancelSession=async(session,reason,origin)=>{if(active!==session)return;focusOutSession(session);await manager.editor.cancel(session.ref.key,session.ref.generation);const result={status:"cancelled",key:session.ref.key,generation:session.ref.generation};const cleanup=clearTerminalSession(session,reason);notifyStopResult(session.ref.key,session.ref,session.onStopResult,reason,origin,result);await cleanup};const abortInFlightStop=(session,reason)=>{if(session.stopTask===void 0||session.linked.controller.signal.aborted){return}session.removeAbortWatch?.();session.removeAbortWatch=void 0;session.linked.controller.abort(new Error(`Editor "${session.ref.key}" forced to stop by ${reason}.`))};const cancelAbortedSession=async session=>{if(active!==session)return;const result=await stopSession(session,"disconnect",true,"owner-abort",false);if(!isTerminalStop(result)){await forceCancelSession(session,"disconnect","owner-abort")}};const resolveDeclaration=async(request,signal)=>{const declaration=request.declaration;if(typeof declaration==="string"){const resolved2=await manager.resolve({kind:"editor",name:declaration,local:request.local,signal});return{name:resolved2.name,definition:resolved2.definition}}if(isRichSelectDeclaration(declaration)){const richDefinition=manager.createRichSelectEditor(declaration);const resolved2=await manager.resolve({kind:"editor",name:"rich-select",definition:richDefinition,signal});return{name:resolved2.name,definition:resolved2.definition}}const resolved=await manager.resolve({kind:"editor",definition:declaration,signal});return{name:resolved.name,definition:resolved.definition}};const controller={async begin(request){if(disposed){notifyStopResult(request.key,void 0,request.onStopResult,"disconnect","disconnect",{status:"cancelled-before-start",key:request.key});return{status:"failed",key:request.key,error:lookupError(request.key,new Error("Editor facade is disconnected."))}}if(request.key.trim().length===0){notifyStopResult(request.key,void 0,request.onStopResult,"api","lifecycle",{status:"cancelled-before-start",key:request.key});return{status:"failed",key:request.key,error:lookupError(request.key,new Error("Editor key must be non-empty."))}}const beginRevision=++revision;if(pending!==void 0){retirePending(pending,"replacement","replacement")}const previous=active;if(previous!==void 0){const stopResult=await stopSession(previous,"replacement",void 0,"replacement");if(beginRevision!==revision||disposed){return{status:"stale",key:request.key}}if(active===previous){return{status:"blocked-by-active",active:previous.ref,stopResult}}}const linked=linkController(request.params.signal);const operation={revision:beginRevision,key:request.key,linked,onStopResult:request.onStopResult,stopNotified:false,removeOwnerAbortWatch:void 0,requestedStop:void 0};pending=operation;const ownerSignal=request.params.signal;if(ownerSignal!==void 0){const onOwnerAbort=()=>{if(pending===operation){retirePending(operation,"disconnect","owner-abort")}};if(ownerSignal.aborted)onOwnerAbort();else{ownerSignal.addEventListener("abort",onOwnerAbort,{once:true});operation.removeOwnerAbortWatch=()=>ownerSignal.removeEventListener("abort",onOwnerAbort)}}let sessionForStop;const stopEditing=(cancel=false)=>{operation.requestedStop={reason:cancel?"escape":"api",cancel,origin:"component"};if(sessionForStop!==void 0&&active===sessionForStop){void stopSession(sessionForStop,operation.requestedStop.reason,operation.requestedStop.cancel,operation.requestedStop.origin)}};try{const resolved=await resolveDeclaration(request,linked.controller.signal);if(disposed||beginRevision!==revision||pending!==operation||linked.controller.signal.aborted){linked.release();notifyPendingStop(operation,disposed?"disconnect":"api",disposed?"disconnect":"lifecycle");return{status:"stale",key:request.key}}const started=await manager.editor.start({key:request.key,componentName:resolved.name,definition:resolved.definition,params:{...request.params,signal:linked.controller.signal,stopEditing}});if(disposed||beginRevision!==revision||pending!==operation||linked.controller.signal.aborted){if(started.status==="started"){await manager.editor.cancel(started.key,started.generation)}linked.release();notifyPendingStop(operation,disposed?"disconnect":"api",disposed?"disconnect":"lifecycle");return{status:"stale",key:request.key}}pending=void 0;operation.removeOwnerAbortWatch?.();operation.removeOwnerAbortWatch=void 0;if(started.status!=="started"&&operation.requestedStop!==void 0){notifyPendingStop(operation,operation.requestedStop.reason,operation.requestedStop.origin)}if(started.status!=="started"){notifyPendingStop(operation,"api","lifecycle")}if(started.status==="cancelled-before-start"){linked.release();return{status:"cancelled-before-start",ref:{key:started.key,generation:started.generation}}}if(started.status==="failed"){linked.release();return{status:"failed",key:request.key,error:started.error}}if(started.status==="stale"){linked.release();return{status:"stale",key:request.key}}const session={ref:{key:started.key,generation:started.generation},gui:started.gui,popup:started.popup,popupPosition:started.popupPosition,params:request.params,commitOptions:request,onStopResult:request.onStopResult,linked,host:void 0,attachment:void 0,attached:false,attachTask:void 0,detachTask:void 0,stopTask:void 0,stopCancelRequested:false,stopOverride:void 0,removeAbortWatch:void 0,focusOutCalled:false,focusOutResult:false};active=session;sessionForStop=session;const onAbort=()=>{void cancelAbortedSession(session)};linked.controller.signal.addEventListener("abort",onAbort,{once:true});session.removeAbortWatch=()=>linked.controller.signal.removeEventListener("abort",onAbort);if(operation.requestedStop!==void 0){const stopResult=await stopSession(session,operation.requestedStop.reason,operation.requestedStop.cancel,operation.requestedStop.origin);return{status:"stopped-before-attach",ref:session.ref,stopResult}}return{status:"started",ref:session.ref,gui:session.gui,popup:session.popup,popupPosition:session.popupPosition,instance:started.instance}}catch(cause){if(pending===operation)pending=void 0;operation.removeOwnerAbortWatch?.();operation.removeOwnerAbortWatch=void 0;if(operation.requestedStop!==void 0){notifyPendingStop(operation,operation.requestedStop.reason,operation.requestedStop.origin)}notifyPendingStop(operation,disposed?"disconnect":"api",disposed?"disconnect":"lifecycle");linked.release();if(disposed||beginRevision!==revision||linked.controller.signal.aborted){return{status:"stale",key:request.key}}const error=lookupError(request.key,cause);safeReport(options.onError,error);return{status:"failed",key:request.key,error}}},attach(ref,host){const session=active;if(session===void 0||!sameRef(session.ref,ref)){return Promise.resolve({status:"stale",ref})}if(session.attachTask!==void 0)return session.attachTask;const task=(async()=>{let placement;let attachment;let attachedByHost=false;let phase="popup";try{if(session.popup&&host.calculatePopupPlacement!==void 0){placement=await host.calculatePopupPlacement({ref:session.ref,gui:session.gui,preferred:session.popupPosition,cellElement:session.params.cellElement,params:session.params,signal:session.linked.controller.signal})}if(!currentSession(session)){return{status:"stale",ref:session.ref}}phase="after-attach";attachment=await host.attach({ref:session.ref,gui:session.gui,mode:session.popup?"popup":"inline",popupPosition:session.popupPosition,placement,cellElement:session.params.cellElement,params:session.params,signal:session.linked.controller.signal});attachedByHost=true;if(!currentSession(session)){await detachOrphan(host,attachment,session,"stale");return{status:"stale",ref:session.ref}}session.host=host;session.attachment=attachment;session.attached=true;const afterAttach=await manager.editor.afterAttach(session.ref.key,session.ref.generation);if(afterAttach.status==="attached"){return{status:"attached",ref:session.ref,mode:session.popup?"popup":"inline"}}const ownedSession=active===session;if(ownedSession){active=void 0;releaseSessionSignal(session);notifyStopResult(session.ref.key,session.ref,session.onStopResult,"api","lifecycle",{status:"cancelled",key:session.ref.key,generation:session.ref.generation})}const cleanup=detachSession(session,afterAttach.status==="stale"?"stale":"attach-failed");await cleanup;if(afterAttach.status==="failed"){safeReport(options.onError,afterAttach.error);return{status:"failed",ref:session.ref,error:afterAttach.error}}return{status:"stale",ref:session.ref}}catch(cause){const ownedSession=active===session;if(ownedSession){active=void 0;releaseSessionSignal(session);notifyStopResult(session.ref.key,session.ref,session.onStopResult,"api","lifecycle",{status:"cancelled",key:session.ref.key,generation:session.ref.generation})}const orphanCleanup=attachedByHost?detachOrphan(host,attachment,session,"attach-failed"):Promise.resolve();await manager.editor.cancel(session.ref.key,session.ref.generation);await orphanCleanup;const error=lifecycleError(phase==="popup"?"POPUP_FAILED":"AFTER_ATTACH_FAILED",phase,session.ref,cause);safeReport(options.onError,error);return{status:"failed",ref:session.ref,error}}})();session.attachTask=task;return task},stop(reason,stopOptions={}){const session=active;if(session===void 0){if(pending!==void 0){return Promise.resolve(retirePending(pending,reason,"controller"))}return Promise.resolve({status:"not-active"})}return stopSession(session,reason,stopOptions.cancel)},async handleKey(event){if(event.isComposing===true)return{handled:false};let reason;if(event.key==="Enter")reason="enter";else if(event.key==="Tab")reason="tab";else if(event.key==="Escape"||event.key==="Esc"){reason="escape"}else{return{handled:false}}try{event.preventDefault?.()}catch{}const result=await controller.stop(reason);if(reason!=="tab")return{handled:true,reason,result};return{handled:true,reason,navigation:event.shiftKey===true?"previous-cell":"next-cell",result}},handleBlur(){return controller.stop("blur")},handleMouseStop(){return controller.stop("mouse")},lookup(){if(active!==void 0){return{status:"mounted",ref:active.ref,gui:active.gui,popup:active.popup,popupPosition:active.popupPosition,attached:active.attached,params:active.params}}return pending===void 0?{status:"idle"}:{status:"starting",key:pending.key}},focusIn(ref){const session=active;if(session===void 0||ref!==void 0&&!sameRef(session.ref,ref)){return false}return focusInSession(session)},focusOut(ref){const session=active;if(session===void 0||ref!==void 0&&!sameRef(session.ref,ref)){return false}return focusOutSession(session)},async destroy(ref){const session=active;if(session===void 0||ref!==void 0&&!sameRef(session.ref,ref)){return false}abortInFlightStop(session,"api");const result=await stopSession(session,"api",true,"controller",false);if(!isTerminalStop(result)){await forceCancelSession(session,"api","controller")}return result.status!=="not-mounted"},async disconnect(){if(disposed)return;disposed=true;++revision;if(pending!==void 0){retirePending(pending,"disconnect","disconnect")}const session=active;if(session!==void 0){abortInFlightStop(session,"disconnect");const result=await stopSession(session,"disconnect",true,"disconnect",false);if(!isTerminalStop(result)){await forceCancelSession(session,"disconnect","disconnect")}}},stats(){return{active:active===void 0?0:1,attached:active!==void 0&&active.attached?1:0,starting:pending===void 0?0:1,disposed,revision}}};return controller}

package/dist/collection/components/grid/core/component/editor-validation-presentation.js

@@ -0,0 +1 @@
+function hasValidationChild(wrapper){try{for(const child of Array.from(wrapper.children)){if(child.classList.contains("sy-grid__cell-editor-validation")){return true}}}catch{return true}return false}function clearValidationAttributesIfUnused(wrapper){if(hasValidationChild(wrapper))return;try{wrapper.removeAttribute("aria-invalid")}catch{}try{wrapper.removeAttribute("data-invalid")}catch{}}export function renderGridEditorValidation(wrapper,message){let element;try{if(!wrapper.isConnected)return null;element=wrapper.ownerDocument.createElement("div");element.className="sy-grid__cell-editor-validation";element.setAttribute("role","alert");element.setAttribute("aria-live","polite");element.textContent=message;wrapper.setAttribute("aria-invalid","true");wrapper.dataset.invalid="true";wrapper.append(element)}catch{try{element?.remove()}catch{}clearValidationAttributesIfUnused(wrapper);return null}let cleared=false;return{wrapper,element,clear(){if(cleared)return;cleared=true;try{element.remove()}catch{}clearValidationAttributesIfUnused(wrapper)}}}

package/dist/collection/components/grid/core/component/filter-adapter.js

@@ -0,0 +1 @@
+import{GridComponentError}from"./contracts.js";import{createGridAsyncValueSource}from"./async-value-source.js";import{createGridComponentRuntime}from"./runtime.js";const DEFAULT_FILTER_STEP_TIMEOUT_MS=5e3;function filterError(code,phase,key,generation,componentName,cause,componentKind="filter"){if(cause instanceof GridComponentError)return cause;return new GridComponentError(`Filter "${componentName??key}" failed during ${phase}.`,{code,phase,componentKind,componentName,mountKey:key,generation,retryable:code!=="ABORTED",cause})}function runFilterStep(operation,options){return new Promise((resolve,reject)=>{let settled=false;let timer;let onAbort;const cleanup=()=>{if(timer!==void 0)clearTimeout(timer);if(onAbort!==void 0){options.signal.removeEventListener("abort",onAbort)}};const resolveOnce=value=>{if(settled)return;settled=true;cleanup();resolve(value)};const rejectOnce=cause=>{if(settled)return;settled=true;cleanup();reject(cause)};if(options.signal.aborted){rejectOnce(filterError("ABORTED",options.phase,options.key,options.generation,options.componentName,options.signal.reason,options.componentKind));return}onAbort=()=>rejectOnce(filterError("ABORTED",options.phase,options.key,options.generation,options.componentName,options.signal.reason,options.componentKind));options.signal.addEventListener("abort",onAbort,{once:true});timer=setTimeout(()=>{rejectOnce(filterError("TIMEOUT",options.phase,options.key,options.generation,options.componentName,new Error(`Timed out after ${options.timeoutMs}ms.`),options.componentKind))},options.timeoutMs);const raw=Promise.resolve().then(()=>settled?void 0:operation());void raw.then(resolveOnce,cause=>rejectOnce(filterError(options.failureCode,options.phase,options.key,options.generation,options.componentName,cause,options.componentKind)))})}function safeReport(onError,error){try{onError?.(error)}catch{}}function enqueueFilterOperation(state,operation){const result=state.tail.then(operation,operation);state.tail=result.then(()=>void 0,()=>void 0);return result}export function createGridFilterAdapter(options={}){const timeoutMs=options.timeoutMs??DEFAULT_FILTER_STEP_TIMEOUT_MS;const compareModels=options.modelsEqual??Object.is;const runtime=createGridComponentRuntime({...options,kind:"filter"});const states=new Map;const valueSources=new Set;let disconnected=false;let disconnectPromise;const report=error=>safeReport(options.onError,error);const modelsEqual=(state,left,right)=>{try{return compareModels(left,right)}catch(cause){report(filterError("MODEL_FAILED","model",state.request.key,state.generation,state.request.componentName,cause));return Object.is(left,right)}};const currentLookup=(key,state)=>{const lookup=runtime.lookup(key);return lookup.status==="mounted"&&states.get(key)===state&&lookup.generation===state.generation?lookup:void 0};const predicateFailure=(state,method,cause)=>{const existing=state.predicateFailures.get(method);if(existing!==void 0)return existing;const error=filterError("MODEL_FAILED","model",state.request.key,state.generation,state.request.componentName,cause);state.predicateFailures.set(method,error);report(error);return error};const readActive=(key,state)=>{const latched=state.predicateFailures.get("isActive");if(latched!==void 0){return{status:"failed",key,generation:state.generation,error:latched}}const lookup=currentLookup(key,state);if(lookup===void 0)return stale(key,state.generation);try{const isActive=lookup.instance.isActive;if(typeof isActive!=="function"){throw new TypeError("Filter isActive must be a function.")}if(currentLookup(key,state)===void 0){return stale(key,state.generation)}const value=isActive.call(lookup.instance);if(currentLookup(key,state)===void 0){return stale(key,state.generation)}if(typeof value!=="boolean"){throw new TypeError("Filter isActive() must return a boolean.")}return{status:"ok",key,generation:state.generation,value}}catch(cause){return{status:"failed",key,generation:state.generation,error:predicateFailure(state,"isActive",cause)}}};const stale=(key,generation)=>({status:"stale",key,generation});const destroyGeneration=async(key,state)=>{if(states.get(key)!==state)return;const lookup=runtime.lookup(key);if(lookup.status!=="mounted"||lookup.generation!==state.generation){return}states.delete(key);await runtime.destroy(key)};const mount=async request=>{states.delete(request.key);const mounted=await runtime.mount({key:request.key,componentName:request.componentName,definition:request.definition,params:request.params});if(mounted.status!=="mounted")return mounted;const lookup=runtime.lookup(request.key);if(lookup.status!=="mounted"||lookup.generation!==mounted.generation){return{status:"stale",key:request.key,generation:mounted.generation}}let model=null;try{const getModel2=lookup.instance.getModel;if(typeof getModel2!=="function"){throw new TypeError("Filter getModel must be a function.")}const ownerAfterCapture=runtime.lookup(request.key);if(ownerAfterCapture.status!=="mounted"||ownerAfterCapture.generation!==mounted.generation){return{status:"stale",key:request.key,generation:mounted.generation}}model=getModel2.call(lookup.instance);await Promise.resolve();const ownerAfterRead=runtime.lookup(request.key);if(ownerAfterRead.status!=="mounted"||ownerAfterRead.generation!==mounted.generation){return{status:"stale",key:request.key,generation:mounted.generation}}}catch(cause){const ownerAfterFailure=runtime.lookup(request.key);if(ownerAfterFailure.status!=="mounted"||ownerAfterFailure.generation!==mounted.generation){return{status:"stale",key:request.key,generation:mounted.generation}}report(filterError("MODEL_FAILED","model",request.key,mounted.generation,request.componentName,cause))}states.set(request.key,{generation:mounted.generation,request,tail:Promise.resolve(),attached:false,scheduledAttached:false,afterAttachPromise:void 0,afterDetachPromise:void 0,latestModelSequence:0,pendingSet:void 0,model,predicateFailures:new Map});return mounted};const afterAttach=(key,generation)=>{const state=states.get(key);if(state===void 0){return Promise.resolve({status:"not-mounted",key})}if(state.generation!==generation){return Promise.resolve({status:"stale",key,generation})}if(state.scheduledAttached){if(state.afterAttachPromise!==void 0){return state.afterAttachPromise}return Promise.resolve({status:"ok",key,generation,value:void 0})}state.scheduledAttached=true;const operation=enqueueFilterOperation(state,async()=>{const lookup=currentLookup(key,state);if(lookup===void 0||state.generation!==generation){return stale(key,generation)}try{const afterGuiAttached=lookup.instance.afterGuiAttached;if(afterGuiAttached!==void 0){if(typeof afterGuiAttached!=="function"){throw new TypeError("Filter afterGuiAttached must be a function when provided.")}if(currentLookup(key,state)===void 0||state.generation!==generation){return stale(key,generation)}await runFilterStep(()=>afterGuiAttached.call(lookup.instance),{phase:"after-attach",failureCode:"AFTER_ATTACH_FAILED",key,generation,componentName:state.request.componentName,signal:lookup.params.signal,timeoutMs})}}catch(cause){if(currentLookup(key,state)===void 0||state.generation!==generation){return stale(key,generation)}const error=cause instanceof GridComponentError?cause:filterError("AFTER_ATTACH_FAILED","after-attach",key,generation,state.request.componentName,cause);report(error);await destroyGeneration(key,state);return{status:"failed",key,generation,error}}if(currentLookup(key,state)===void 0||state.generation!==generation){return stale(key,generation)}state.attached=true;return{status:"ok",key,generation,value:void 0}}).finally(()=>{if(state.afterAttachPromise===operation){state.afterAttachPromise=void 0}});state.afterAttachPromise=operation;return operation};const afterDetach=(key,generation)=>{const state=states.get(key);if(state===void 0){return Promise.resolve({status:"not-mounted",key})}if(state.generation!==generation){return Promise.resolve({status:"stale",key,generation})}if(!state.scheduledAttached){if(state.afterDetachPromise!==void 0){return state.afterDetachPromise}return Promise.resolve({status:"ok",key,generation,value:void 0})}state.scheduledAttached=false;const operation=enqueueFilterOperation(state,async()=>{const lookup=currentLookup(key,state);if(lookup===void 0||state.generation!==generation){return stale(key,generation)}if(!state.attached){return{status:"ok",key,generation,value:void 0}}try{const afterGuiDetached=lookup.instance.afterGuiDetached;if(afterGuiDetached!==void 0){if(typeof afterGuiDetached!=="function"){throw new TypeError("Filter afterGuiDetached must be a function when provided.")}if(currentLookup(key,state)===void 0||state.generation!==generation){return stale(key,generation)}await runFilterStep(()=>afterGuiDetached.call(lookup.instance),{phase:"after-detach",failureCode:"AFTER_DETACH_FAILED",key,generation,componentName:state.request.componentName,signal:lookup.params.signal,timeoutMs})}}catch(cause){if(currentLookup(key,state)===void 0||state.generation!==generation){return stale(key,generation)}const error=cause instanceof GridComponentError?cause:filterError("AFTER_DETACH_FAILED","after-detach",key,generation,state.request.componentName,cause);report(error);state.attached=false;return{status:"failed",key,generation,error}}if(currentLookup(key,state)===void 0||state.generation!==generation){return stale(key,generation)}state.attached=false;return{status:"ok",key,generation,value:void 0}}).finally(()=>{if(state.afterDetachPromise===operation){state.afterDetachPromise=void 0}});state.afterDetachPromise=operation;return operation};const setModel=(key,model)=>{const state=states.get(key);if(state===void 0){return Promise.resolve({status:"not-mounted",key})}if(state.pendingSet!==void 0&&modelsEqual(state,state.pendingSet.model,model)){return state.pendingSet.promise}const sequence=++state.latestModelSequence;const operation=enqueueFilterOperation(state,async()=>{const lookup=currentLookup(key,state);if(lookup===void 0||sequence!==state.latestModelSequence){return stale(key,state.generation)}try{const setModelMethod=lookup.instance.setModel;if(typeof setModelMethod!=="function"){throw new TypeError("Filter setModel must be a function.")}if(currentLookup(key,state)===void 0||sequence!==state.latestModelSequence){return stale(key,state.generation)}await runFilterStep(()=>setModelMethod.call(lookup.instance,model),{phase:"model",failureCode:"MODEL_FAILED",key,generation:state.generation,componentName:state.request.componentName,signal:lookup.params.signal,timeoutMs})}catch(cause){const error=cause instanceof GridComponentError?cause:filterError("MODEL_FAILED","model",key,state.generation,state.request.componentName,cause);if(currentLookup(key,state)===void 0||sequence!==state.latestModelSequence){if(error.code==="TIMEOUT"&&currentLookup(key,state)!==void 0){report(error);await destroyGeneration(key,state)}return stale(key,state.generation)}report(error);if(error.code==="TIMEOUT"){await destroyGeneration(key,state)}return{status:"failed",key,generation:state.generation,error}}const current=currentLookup(key,state);if(current===void 0||sequence!==state.latestModelSequence){return stale(key,state.generation)}state.model=model;state.predicateFailures.clear();return{status:"ok",key,generation:state.generation,value:void 0}}).finally(()=>{if(state.pendingSet?.promise===operation){state.pendingSet=void 0}});state.pendingSet={model,promise:operation};return operation};const getModel=key=>{const state=states.get(key);if(state===void 0){return Promise.resolve({status:"not-mounted",key})}return enqueueFilterOperation(state,async()=>{const lookup=currentLookup(key,state);if(lookup===void 0)return stale(key,state.generation);try{const getModel2=lookup.instance.getModel;if(typeof getModel2!=="function"){throw new TypeError("Filter getModel must be a function.")}if(currentLookup(key,state)===void 0){return stale(key,state.generation)}const value=getModel2.call(lookup.instance);await Promise.resolve();if(currentLookup(key,state)===void 0){return stale(key,state.generation)}state.model=value;return{status:"ok",key,generation:state.generation,value}}catch(cause){const error=filterError("MODEL_FAILED","model",key,state.generation,state.request.componentName,cause);report(error);return{status:"failed",key,generation:state.generation,error}}})};const modelAsString=(key,suppliedModel)=>{const state=states.get(key);if(state===void 0){return Promise.resolve({status:"not-mounted",key})}return enqueueFilterOperation(state,async()=>{const lookup=currentLookup(key,state);if(lookup===void 0)return stale(key,state.generation);try{let model=suppliedModel;if(model===void 0){const getModel2=lookup.instance.getModel;if(typeof getModel2!=="function"){throw new TypeError("Filter getModel must be a function.")}if(currentLookup(key,state)===void 0){return stale(key,state.generation)}model=getModel2.call(lookup.instance);if(currentLookup(key,state)===void 0){return stale(key,state.generation)}}const getModelAsString=lookup.instance.getModelAsString;if(getModelAsString!==void 0&&typeof getModelAsString!=="function"){throw new TypeError("Filter getModelAsString must be a function when provided.")}if(currentLookup(key,state)===void 0){return stale(key,state.generation)}const value=getModelAsString?.call(lookup.instance,model);await Promise.resolve();if(currentLookup(key,state)===void 0){return stale(key,state.generation)}return{status:"ok",key,generation:state.generation,value}}catch(cause){const error=filterError("MODEL_FAILED","model",key,state.generation,state.request.componentName,cause);report(error);return{status:"failed",key,generation:state.generation,error}}})};const notify=(key,method)=>{const state=states.get(key);if(state===void 0){return Promise.resolve({status:"not-mounted",key})}return enqueueFilterOperation(state,async()=>{const lookup=currentLookup(key,state);if(lookup===void 0)return stale(key,state.generation);try{const hook=lookup.instance[method];if(hook!==void 0){if(typeof hook!=="function"){throw new TypeError(`Filter ${method} must be a function when provided.`)}if(currentLookup(key,state)===void 0){return stale(key,state.generation)}await runFilterStep(()=>hook.call(lookup.instance),{phase:"model",failureCode:"MODEL_FAILED",key,generation:state.generation,componentName:state.request.componentName,signal:lookup.params.signal,timeoutMs})}if(currentLookup(key,state)===void 0){return stale(key,state.generation)}return{status:"ok",key,generation:state.generation,value:void 0}}catch(cause){if(currentLookup(key,state)===void 0){return stale(key,state.generation)}const error=cause instanceof GridComponentError?cause:filterError("MODEL_FAILED","model",key,state.generation,state.request.componentName,cause);report(error);return{status:"failed",key,generation:state.generation,error}}})};const refresh=(key,params)=>{const state=states.get(key);if(state===void 0){return Promise.resolve({status:"not-mounted",key})}return enqueueFilterOperation(state,async()=>{if(currentLookup(key,state)===void 0){return{status:"stale",key,generation:state.generation}}const result=await runtime.refresh(key,params);if(result.status==="failed"||result.status==="not-mounted"){if(states.get(key)===state)states.delete(key);return result}if(result.status==="stale")return result;state.generation=result.generation;state.request={...state.request,params};state.predicateFailures.clear();if(result.status==="recreated"){state.attached=false;state.scheduledAttached=false;state.afterAttachPromise=void 0;state.afterDetachPromise=void 0}return result})};return{runtime,mount,afterAttach,afterDetach,refresh,getActive(key){const state=states.get(key);return state===void 0?{status:"not-mounted",key}:readActive(key,state)},isActive(key){const state=states.get(key);if(state===void 0)return false;const result=readActive(key,state);return result.status==="ok"?result.value:result.status==="failed"},doesPass(key,data){const state=states.get(key);if(state===void 0)return true;if(state.predicateFailures.has("doesPass"))return false;const lookup=currentLookup(key,state);if(lookup===void 0)return true;try{const doesFilterPass=lookup.instance.doesFilterPass;if(typeof doesFilterPass!=="function"){throw new TypeError("Filter doesFilterPass must be a function.")}if(currentLookup(key,state)===void 0){return false}const value=doesFilterPass.call(lookup.instance,data);if(currentLookup(key,state)===void 0){return false}if(typeof value!=="boolean"){throw new TypeError("Filter doesFilterPass() must return a boolean.")}return value}catch(cause){predicateFailure(state,"doesPass",cause);return false}},getModel,setModel,modelAsString,onNewRowsLoaded(key){return notify(key,"onNewRowsLoaded")},onAnyFilterChanged(key){return notify(key,"onAnyFilterChanged")},destroy(key){states.delete(key);return runtime.destroy(key)},async recreate(key,replacement,recreateOptions){const previous=states.get(key);if(previous===void 0&&replacement===void 0){return{status:"not-mounted",key}}const preserveModel=recreateOptions?.preserveModel??true;let preservedModel=null;if(previous!==void 0&&preserveModel){const captured=await getModel(key);if(captured.status!=="ok"){if(captured.status==="failed"){return{status:"failed",key,generation:captured.generation,error:captured.error}}return{status:"stale",key,generation:previous.generation}}preservedModel=captured.value;if(states.get(key)!==previous){return{status:"stale",key,generation:previous.generation}}}const request=replacement?{key,...replacement}:{...previous.request,key};if(previous!==void 0&&previous.scheduledAttached&&states.get(key)===previous){const detached=await afterDetach(key,previous.generation);if(detached.status==="failed"){return{status:"failed",key,generation:detached.generation,error:detached.error}}if(detached.status!=="ok"){return{status:"stale",key,generation:previous.generation}}}if(previous!==void 0&&states.get(key)!==previous){return{status:"stale",key,generation:previous.generation}}states.delete(key);await runtime.destroy(key);const mounted=await mount(request);if(mounted.status!=="mounted"||!preserveModel||previous===void 0){return mounted}const restored=await setModel(key,preservedModel);if(restored.status==="ok")return mounted;if(restored.status==="failed"){const replacementState=states.get(key);if(replacementState!==void 0&&replacementState.generation===mounted.generation){states.delete(key);await runtime.destroy(key)}return{status:"failed",key,generation:mounted.generation,error:restored.error}}return{status:"stale",key,generation:mounted.generation}},async destroyAll(){states.clear();await runtime.destroyAll()},createValueSource(loader){const source=createGridAsyncValueSource(loader);let released=false;const tracked={load(query,loadOptions){return source.load(query,loadOptions)},refresh(refreshOptions){return source.refresh(refreshOptions)},snapshot(){return source.snapshot()},subscribe(listener){return source.subscribe(listener)},destroy(){if(released)return;released=true;valueSources.delete(tracked);source.destroy()}};if(disconnected){tracked.destroy()}else{valueSources.add(tracked)}return tracked},disconnect(){disconnectPromise??=(async()=>{disconnected=true;states.clear();for(const source of valueSources)source.destroy();valueSources.clear();await runtime.dispose()})();return disconnectPromise}}}export function createGridFloatingFilterAdapter(options={}){const timeoutMs=options.timeoutMs??DEFAULT_FILTER_STEP_TIMEOUT_MS;const compareModels=options.modelsEqual??Object.is;const runtime=createGridComponentRuntime({...options,kind:"floatingFilter"});const states=new Map;let disconnectPromise;const report=error=>safeReport(options.onError,error);const modelsEqual=(state,left,right)=>{try{return compareModels(left,right)}catch(cause){report(filterError("MODEL_FAILED","model",state.key,state.generation,state.componentName,cause,"floatingFilter"));return Object.is(left,right)}};const currentLookup=state=>{const lookup=runtime.lookup(state.key);return states.get(state.key)===state&&lookup.status==="mounted"&&lookup.generation===state.generation?lookup:void 0};const destroyGeneration=async state=>{if(states.get(state.key)!==state)return;const lookup=runtime.lookup(state.key);if(lookup.status!=="mounted"||lookup.generation!==state.generation){return}states.delete(state.key);await runtime.destroy(state.key)};const emitChildModel=(state,model)=>{if(currentLookup(state)===void 0){return}if(state.applyingParent>0&&modelsEqual(state,state.applyingParentModel,model)){return}if(modelsEqual(state,state.model,model))return;if(state.applyingParent>0){state.latestParentSequence+=1;state.pendingParent=void 0}state.model=model;try{state.hostOnModelChange(model)}catch(cause){report(filterError("MODEL_FAILED","model",state.key,state.generation,state.componentName,cause,"floatingFilter"))}};const mount=async request=>{states.delete(request.key);let state;let hasBufferedChild=false;let bufferedChild=null;const onModelChange=model=>{if(state===void 0){hasBufferedChild=true;bufferedChild=model;return}emitChildModel(state,model)};const mounted=await runtime.mount({key:request.key,componentName:request.componentName,definition:request.definition,params:{...request.params,onModelChange}});if(mounted.status!=="mounted")return mounted;const lookup=runtime.lookup(request.key);if(lookup.status!=="mounted"||lookup.generation!==mounted.generation){return{status:"stale",key:request.key,generation:mounted.generation}}state={key:request.key,componentName:request.componentName,hostOnModelChange:request.params.onModelChange,generation:mounted.generation,model:request.params.parentModel,attached:false,scheduledAttached:false,afterAttachPromise:void 0,afterDetachPromise:void 0,applyingParent:0,applyingParentModel:request.params.parentModel,latestParentSequence:0,tail:Promise.resolve(),pendingParent:void 0};states.set(request.key,state);if(hasBufferedChild)emitChildModel(state,bufferedChild);return mounted};const afterAttach=(key,generation)=>{const state=states.get(key);if(state===void 0){return Promise.resolve({status:"not-mounted",key})}if(state.generation!==generation){return Promise.resolve({status:"stale",key,generation})}if(state.scheduledAttached){if(state.afterAttachPromise!==void 0){return state.afterAttachPromise}return Promise.resolve({status:"ok",key,generation,value:void 0})}state.scheduledAttached=true;const operation=enqueueFilterOperation(state,async()=>{const lookup=currentLookup(state);if(lookup===void 0||state.generation!==generation){return{status:"stale",key,generation}}try{const afterGuiAttached=lookup.instance.afterGuiAttached;if(afterGuiAttached!==void 0){if(typeof afterGuiAttached!=="function"){throw new TypeError("Floating filter afterGuiAttached must be a function when provided.")}if(currentLookup(state)===void 0||state.generation!==generation){return{status:"stale",key,generation}}await runFilterStep(()=>afterGuiAttached.call(lookup.instance),{phase:"after-attach",failureCode:"AFTER_ATTACH_FAILED",key,generation,componentName:state.componentName,signal:lookup.params.signal,timeoutMs,componentKind:"floatingFilter"})}}catch(cause){if(currentLookup(state)===void 0||state.generation!==generation){return{status:"stale",key,generation}}const error=cause instanceof GridComponentError?cause:filterError("AFTER_ATTACH_FAILED","after-attach",key,generation,state.componentName,cause,"floatingFilter");report(error);await destroyGeneration(state);return{status:"failed",key,generation,error}}if(currentLookup(state)===void 0||state.generation!==generation){return{status:"stale",key,generation}}state.attached=true;return{status:"ok",key,generation,value:void 0}}).finally(()=>{if(state.afterAttachPromise===operation){state.afterAttachPromise=void 0}});state.afterAttachPromise=operation;return operation};const afterDetach=(key,generation)=>{const state=states.get(key);if(state===void 0){return Promise.resolve({status:"not-mounted",key})}if(state.generation!==generation){return Promise.resolve({status:"stale",key,generation})}if(!state.scheduledAttached){if(state.afterDetachPromise!==void 0){return state.afterDetachPromise}return Promise.resolve({status:"ok",key,generation,value:void 0})}state.scheduledAttached=false;const operation=enqueueFilterOperation(state,async()=>{const lookup=currentLookup(state);if(lookup===void 0||state.generation!==generation){return{status:"stale",key,generation}}if(!state.attached){return{status:"ok",key,generation,value:void 0}}try{const afterGuiDetached=lookup.instance.afterGuiDetached;if(afterGuiDetached!==void 0){if(typeof afterGuiDetached!=="function"){throw new TypeError("Floating filter afterGuiDetached must be a function when provided.")}if(currentLookup(state)===void 0||state.generation!==generation){return{status:"stale",key,generation}}await runFilterStep(()=>afterGuiDetached.call(lookup.instance),{phase:"after-detach",failureCode:"AFTER_DETACH_FAILED",key,generation,componentName:state.componentName,signal:lookup.params.signal,timeoutMs,componentKind:"floatingFilter"})}}catch(cause){if(currentLookup(state)===void 0||state.generation!==generation){return{status:"stale",key,generation}}const error=cause instanceof GridComponentError?cause:filterError("AFTER_DETACH_FAILED","after-detach",key,generation,state.componentName,cause,"floatingFilter");report(error);state.attached=false;return{status:"failed",key,generation,error}}if(currentLookup(state)===void 0||state.generation!==generation){return{status:"stale",key,generation}}state.attached=false;return{status:"ok",key,generation,value:void 0}}).finally(()=>{if(state.afterDetachPromise===operation){state.afterDetachPromise=void 0}});state.afterDetachPromise=operation;return operation};const parentModelChanged=(key,model,source,force=false)=>{const state=states.get(key);if(state===void 0){return Promise.resolve({status:"not-mounted",key})}if(!force&&state.pendingParent&&modelsEqual(state,state.pendingParent.model,model)){return state.pendingParent.promise}if(!force&&modelsEqual(state,state.model,model)){return Promise.resolve({status:"ok",key,generation:state.generation,value:void 0})}const sequence=++state.latestParentSequence;const operation=enqueueFilterOperation(state,async()=>{const lookup=currentLookup(state);if(lookup===void 0||sequence!==state.latestParentSequence){return{status:"stale",key,generation:state.generation}}state.applyingParent+=1;state.applyingParentModel=model;try{const onParentModelChanged=lookup.instance.onParentModelChanged;if(typeof onParentModelChanged!=="function"){throw new TypeError("Floating filter onParentModelChanged must be a function.")}if(currentLookup(state)===void 0||sequence!==state.latestParentSequence){return{status:"stale",key,generation:state.generation}}await runFilterStep(()=>onParentModelChanged.call(lookup.instance,model,source),{phase:"model",failureCode:"MODEL_FAILED",key,generation:state.generation,componentName:state.componentName,signal:lookup.params.signal,timeoutMs,componentKind:"floatingFilter"})}catch(cause){const error=cause instanceof GridComponentError?cause:filterError("MODEL_FAILED","model",key,state.generation,state.componentName,cause,"floatingFilter");if(currentLookup(state)===void 0||sequence!==state.latestParentSequence){if(error.code==="TIMEOUT"&&currentLookup(state)!==void 0){report(error);await destroyGeneration(state)}return{status:"stale",key,generation:state.generation}}report(error);if(error.code==="TIMEOUT"){await destroyGeneration(state)}return{status:"failed",key,generation:state.generation,error}}finally{state.applyingParent-=1}if(currentLookup(state)===void 0||sequence!==state.latestParentSequence){return{status:"stale",key,generation:state.generation}}state.model=model;return{status:"ok",key,generation:state.generation,value:void 0}}).finally(()=>{if(state.pendingParent?.promise===operation){state.pendingParent=void 0}});state.pendingParent={model,promise:operation};return operation};return{runtime,mount,afterAttach,afterDetach,parentModelChanged,destroy(key){states.delete(key);return runtime.destroy(key)},async destroyAll(){states.clear();await runtime.destroyAll()},disconnect(){disconnectPromise??=(async()=>{states.clear();await runtime.dispose()})();return disconnectPromise}}}const EXTERNAL_FILTER_OWNERS=new WeakMap;const EXTERNAL_FILTER_DESTROYED=new WeakSet;const EXTERNAL_FILTER_INVALID=new WeakSet;const EXTERNAL_FILTER_DESTROY_TASKS=new WeakMap;const EXTERNAL_FILTER_RELEASE_WAITERS=new WeakMap;function externalFilterReuseError(key,source){return new GridComponentError(`External filter "${key}" reused a lifecycle source that is already owned or destroyed.`,{code:"INVALID_INSTANCE",phase:"create",componentKind:"filter",mountKey:key,retryable:true,cause:source})}export function subscribeGridExternalFilterAvailability(source,callback){const sourceObject=source;if(EXTERNAL_FILTER_DESTROYED.has(sourceObject)||EXTERNAL_FILTER_INVALID.has(sourceObject)){return()=>void 0}let active=true;const notify=()=>{if(!active)return;active=false;callback()};if(!EXTERNAL_FILTER_OWNERS.has(sourceObject)){queueMicrotask(notify);return()=>{active=false}}const waiters=EXTERNAL_FILTER_RELEASE_WAITERS.get(sourceObject)??new Set;waiters.add(notify);EXTERNAL_FILTER_RELEASE_WAITERS.set(sourceObject,waiters);return()=>{active=false;waiters.delete(notify);if(waiters.size===0){EXTERNAL_FILTER_RELEASE_WAITERS.delete(sourceObject)}}}function linkExternalAbort(controller,parent){if(parent===void 0)return()=>void 0;const onAbort=()=>controller.abort(parent.reason);if(parent.aborted){onAbort();return()=>void 0}parent.addEventListener("abort",onAbort,{once:true});return()=>parent.removeEventListener("abort",onAbort)}export function createGridExternalFilterController(source,options={}){const key=options.key??"external-filter";const timeoutMs=options.timeoutMs??DEFAULT_FILTER_STEP_TIMEOUT_MS;const instance=source;const sourceObject=source;if(source===null||typeof source!=="object"&&typeof source!=="function"){throw new GridComponentError(`External filter "${key}" must be a lifecycle or callback object.`,{code:"INVALID_INSTANCE",phase:"create",componentKind:"filter",mountKey:key,retryable:true,cause:source})}if(EXTERNAL_FILTER_INVALID.has(sourceObject)){throw externalFilterReuseError(key,sourceObject)}let presenceMethod;let predicateMethod;let refreshMethod;let destroyMethod;let accessorFailure;let accessorFailed=false;const capture=read=>{try{return read()}catch(cause){accessorFailed=true;accessorFailure??=cause;return void 0}};presenceMethod=capture(()=>source.isExternalFilterPresent);predicateMethod=capture(()=>source.doesExternalFilterPass);refreshMethod=capture(()=>instance.refresh);destroyMethod=capture(()=>instance.destroy);const malformed=accessorFailed||typeof presenceMethod!=="function"||typeof predicateMethod!=="function"||refreshMethod!==void 0&&typeof refreshMethod!=="function"||destroyMethod!==void 0&&typeof destroyMethod!=="function";if(malformed){EXTERNAL_FILTER_INVALID.add(sourceObject);if(typeof destroyMethod==="function"){EXTERNAL_FILTER_DESTROYED.add(sourceObject);const rawDestroy=Promise.resolve().then(()=>destroyMethod.call(source)).then(()=>void 0,cause=>{safeReport(options.onError,filterError("DESTROY_FAILED","destroy",key,0,void 0,cause))});EXTERNAL_FILTER_DESTROY_TASKS.set(sourceObject,rawDestroy)}throw new GridComponentError(`External filter "${key}" returned a malformed callback or lifecycle object.`,{code:"INVALID_INSTANCE",phase:"create",componentKind:"filter",mountKey:key,retryable:true,cause:accessorFailure})}const isPresentCallback=presenceMethod;const doesPassCallback=predicateMethod;const refreshCallback=refreshMethod;const destroyCallback=destroyMethod;const ownsLifecycle=refreshCallback!==void 0||destroyCallback!==void 0;const destroysLifecycle=destroyCallback!==void 0;const ownerToken={};if(ownsLifecycle&&(EXTERNAL_FILTER_OWNERS.has(sourceObject)||destroysLifecycle&&EXTERNAL_FILTER_DESTROYED.has(sourceObject))){throw externalFilterReuseError(key,sourceObject)}if(ownsLifecycle){EXTERNAL_FILTER_OWNERS.set(sourceObject,ownerToken)}let generation=0;let destroyed=false;let active;let destroyPromise;const pendingRawRefreshes=new Set;let releaseScheduled=false;const reportedPredicateFailures=new Set;let lastPredicateError=null;let cachedPresence;const report=error=>safeReport(options.onError,error);const releaseOwnership=()=>{if(EXTERNAL_FILTER_OWNERS.get(sourceObject)===ownerToken){EXTERNAL_FILTER_OWNERS.delete(sourceObject);if(!EXTERNAL_FILTER_DESTROYED.has(sourceObject)){const waiters=EXTERNAL_FILTER_RELEASE_WAITERS.get(sourceObject);EXTERNAL_FILTER_RELEASE_WAITERS.delete(sourceObject);for(const notify of waiters??[]){queueMicrotask(notify)}}}};const releaseRefreshOnlyOwnershipWhenSettled=()=>{if(!ownsLifecycle||destroysLifecycle||!destroyed)return;if(pendingRawRefreshes.size===0){releaseOwnership();return}if(releaseScheduled)return;releaseScheduled=true;const pending=[...pendingRawRefreshes];void Promise.all(pending).then(()=>{releaseScheduled=false;releaseRefreshOnlyOwnershipWhenSettled()})};const runRefresh=(context,controller,currentGeneration)=>{let started=false;let settleRaw;const rawSettlement=new Promise(resolve=>{settleRaw=resolve});pendingRawRefreshes.add(rawSettlement);void rawSettlement.then(()=>{pendingRawRefreshes.delete(rawSettlement);releaseRefreshOnlyOwnershipWhenSettled()});return runFilterStep(()=>{started=true;let raw;try{raw=Promise.resolve(refreshCallback.call(source,context,controller.signal))}catch(cause){raw=Promise.reject(cause)}void raw.then(settleRaw,settleRaw);return raw},{phase:"refresh",failureCode:"REFRESH_FAILED",key,generation:currentGeneration,signal:controller.signal,timeoutMs}).finally(()=>{if(!started)settleRaw()})};const predicateError=cause=>filterError("MODEL_FAILED","model",key,generation,void 0,cause);const recordPredicateFailure=(method,cause)=>{const error=predicateError(cause);lastPredicateError=error;if(!reportedPredicateFailures.has(method)){reportedPredicateFailures.add(method);report(error)}return error};return{getPredicateError(){return lastPredicateError},isPresent(){if(destroyed)return false;if(lastPredicateError!==null)return true;if(cachedPresence!==void 0)return cachedPresence;try{const value=isPresentCallback.call(source);if(typeof value!=="boolean"){throw new TypeError("External isExternalFilterPresent() must return a boolean.")}cachedPresence=value;return value}catch(cause){recordPredicateFailure("isPresent",cause);return true}},doesPass(data){if(destroyed)return true;if(lastPredicateError!==null)return false;try{const value=doesPassCallback.call(source,data);if(typeof value!=="boolean"){throw new TypeError("External doesExternalFilterPass() must return a boolean.")}return value}catch(cause){recordPredicateFailure("doesPass",cause);return false}},async refresh(context,refreshOptions={}){const currentGeneration=++generation;if(destroyed){return{status:"stale",generation:currentGeneration}}active?.controller.abort("external filter refresh superseded");active?.removeParentAbort();const controller=new AbortController;const removeParentAbort=linkExternalAbort(controller,refreshOptions.signal);active={generation:currentGeneration,controller,removeParentAbort};try{if(refreshCallback!==void 0){await runRefresh(context,controller,currentGeneration)}if(destroyed||active?.generation!==currentGeneration||controller.signal.aborted){return{status:"stale",generation:currentGeneration}}reportedPredicateFailures.clear();lastPredicateError=null;cachedPresence=void 0;return{status:"refreshed",generation:currentGeneration}}catch(cause){if(destroyed||active?.generation!==currentGeneration){return{status:"stale",generation:currentGeneration}}const error=cause instanceof GridComponentError?cause:filterError("REFRESH_FAILED","refresh",key,currentGeneration,void 0,cause);if(error.code==="TIMEOUT")controller.abort("refresh timeout");report(error);return{status:"failed",generation:currentGeneration,error}}finally{if(active?.generation===currentGeneration){active.removeParentAbort();active=void 0}}},destroy(){destroyPromise??=(async()=>{destroyed=true;active?.controller.abort("external filter destroyed");active?.removeParentAbort();active=void 0;if(destroyCallback===void 0){releaseRefreshOnlyOwnershipWhenSettled();return}EXTERNAL_FILTER_DESTROYED.add(sourceObject);const existingDestroy=EXTERNAL_FILTER_DESTROY_TASKS.get(sourceObject);if(existingDestroy!==void 0){await existingDestroy;releaseOwnership();return}const controller=new AbortController;const task=(async()=>{try{await runFilterStep(()=>destroyCallback.call(source),{phase:"destroy",failureCode:"DESTROY_FAILED",key,generation,signal:controller.signal,timeoutMs})}catch(cause){const error=cause instanceof GridComponentError?cause:filterError("DESTROY_FAILED","destroy",key,generation,void 0,cause);report(error)}finally{releaseOwnership()}})();EXTERNAL_FILTER_DESTROY_TASKS.set(sourceObject,task);await task})();return destroyPromise}}}

package/dist/collection/components/grid/core/component/filter-facade-controller.js

@@ -0,0 +1 @@
+import{GridComponentError}from"./contracts.js";let filterFacadeSequence=0;function filterKey(ownerId,colId){return`${ownerId}:filter:${encodeURIComponent(colId)}`}function floatingKey(ownerId,colId){return`${ownerId}:floating-filter:${encodeURIComponent(colId)}`}function declarationName(value){return typeof value==="string"?value.trim()||void 0:void 0}function defaultHostConnected(host){const connected=host.isConnected;return connected===void 0||connected}function removeOwnedGui(attachment){if(attachment===void 0)return;const[host,gui]=attachment;if(gui.parentNode===host&&typeof host.removeChild==="function"){host.removeChild(gui)}}function isPlainRecord(value){const prototype=Object.getPrototypeOf(value);return prototype===Object.prototype||prototype===null}function canonicalizeSerializable(value,seen,path,depth){if(value===null)return null;if(typeof value==="string"||typeof value==="boolean"){return value}if(typeof value==="number"){if(!Number.isFinite(value)){throw new TypeError(`${path} contains a non-finite number.`)}return Object.is(value,-0)?0:value}if(typeof value!=="object"){throw new TypeError(`${path} is not JSON-serializable.`)}if(depth>100){throw new TypeError(`${path} exceeds the maximum model depth.`)}if(seen.has(value)){throw new TypeError(`${path} contains a circular reference.`)}seen.add(value);try{if(Array.isArray(value)){return Object.freeze(value.map((entry,index)=>canonicalizeSerializable(entry,seen,`${path}[${index}]`,depth+1)))}if(!isPlainRecord(value)){throw new TypeError(`${path} must contain only plain objects.`)}for(const key of Object.getOwnPropertySymbols(value)){if(Object.prototype.propertyIsEnumerable.call(value,key)){throw new TypeError(`${path} contains an enumerable symbol key.`)}}const output=Object.create(null);for(const key of Object.keys(value).sort()){output[key]=canonicalizeSerializable(value[key],seen,`${path}.${key}`,depth+1)}return Object.freeze(output)}finally{seen.delete(value)}}export function createGridFilterFacadeController(options){const manager=options.manager;const ownerId=options.ownerId?.trim()||`filter-facade-${filterFacadeSequence+=1}`;const states=new Map;const lifecycleController=new AbortController;let executionMode=typeof options.executionMode==="function"?"server":options.executionMode??"client";let reconcileRequestRevision=0;let appliedReconcileRevision=0;let modelRevision=0;let disconnected=false;let operationTail=Promise.resolve();let disconnectTask;let latestReconcileIntent;function enqueue(operation){const result=operationTail.then(operation,operation);operationTail=result.then(()=>void 0,()=>void 0);return result}function context(){return options.getContext?.()??options.context}function captureContext(){try{return{status:"ok",value:context()}}catch(cause){return{status:"failed",cause}}}function captureReconcileIntent(revision,columns,capturedContext){const desired=new Map;const seen=new Set;const ambiguous=new Set;for(const column of columns){const colId=column.colId.trim();if(!colId)continue;if(seen.has(colId)){ambiguous.add(colId);continue}seen.add(colId);if(column.filter!=null){desired.set(colId,{...column,colId})}}return{revision,desired,ambiguous,context:capturedContext}}function latestIntentRetains(column,nextContext,revisionOrFloating){const intent=latestReconcileIntent;if(intent===void 0||intent.revision!==reconcileRequestRevision||typeof revisionOrFloating==="number"&&intent.revision<=revisionOrFloating||intent.context.status!=="ok"||!Object.is(intent.context.value,nextContext)||intent.ambiguous.has(column.colId)){return false}const latest=intent.desired.get(column.colId);return latest!==void 0&&Object.is(latest.local,column.local)&&Object.is(latest.version,column.version)&&Object.is(latest.resolutionVersion,column.resolutionVersion)&&(typeof revisionOrFloating==="number"?Object.is(latest.filter,column.filter)&&Object.is(latest.floatingFilter,column.floatingFilter)&&Object.is(latest.getValue,column.getValue):revisionOrFloating?Object.is(latest.floatingFilter,column.floatingFilter):Object.is(latest.filter,column.filter)&&Object.is(latest.getValue,column.getValue))}function reconcileColumnSnapshot(state){return{colId:state.id,filter:state.filterSrc??null,floatingFilter:state.floatingSrc,getValue:state.valueOf,local:state.defs,version:state.version,resolutionVersion:state.resolveVersion}}function operationIntentOwned(column,operationContext,requestRevision){return requestRevision===reconcileRequestRevision||latestIntentRetains(column,operationContext,requestRevision)}function filterOperationOwned(state,epoch,generation,column,operationContext,requestRevision){return ownsExactFilterGeneration(state,epoch,generation)&&operationIntentOwned(column,operationContext,requestRevision)}function floatingCallbackOwned(state,owner){const floating=currentFloatingLookup(state);return state.floatingOwner===owner&&state.life[3]===owner[3]&&floating?.generation===owner[2]&&ownsExactFilterGeneration(state,owner[0],owner[1])&&latestIntentRetains(owner[4],owner[5],true)}function rebindFloatingCallback(state,epoch,filterGeneration){const owner=state.floatingOwner;if(owner===void 0||state.life[3]!==owner[3]||state.life[5]!==owner[2]||!latestIntentRetains(owner[4],owner[5],true)){return}owner[0]=epoch;owner[1]=filterGeneration}function mode(){try{if(typeof options.executionMode==="function"){executionMode=options.executionMode()}if(executionMode!=="client"&&executionMode!=="server"&&executionMode!=="infinite"){throw new TypeError(`Unknown filter execution mode "${String(executionMode)}".`)}}catch(cause){report(facadeError("MODEL_FAILED","model","filter","Filter execution mode could not be resolved.",void 0,cause));return"server"}return executionMode}function report(error){try{options.onError?.(error)}catch{}}function facadeError(code,phase,componentKind,message,state,cause){if(cause instanceof GridComponentError)return cause;return new GridComponentError(message,{code,phase,componentKind,componentName:componentKind==="filter"?state?.fName:state?.ffName,mountKey:componentKind==="filter"?state?.fKey:state?.ffKey,generation:componentKind==="filter"?state?.life[4]:state?.life[5],retryable:code!=="INVALID_NAME",cause})}function modelsEqual(left,right,state){try{return options.modelsEqual?.(left,right)??Object.is(left,right)}catch(cause){const error=facadeError("MODEL_FAILED","model","filter",`Filter "${state?.id??"<unknown>"}" model comparison failed.`,state,cause);report(error);return Object.is(left,right)}}function fingerprintModel(model){try{return JSON.stringify(canonicalizeSerializable(model,new Set,"filterModel",0))}catch{return void 0}}function comparePublishedModel(state,next){const fingerprint=fingerprintModel(next);if(state.fingerprint!==void 0&&fingerprint!==void 0){return{changed:state.fingerprint!==fingerprint,fingerprint}}return{changed:!modelsEqual(state.published,next,state),fingerprint}}function hostConnection(host,state,componentKind){try{return{connected:(options.isHostConnected??defaultHostConnected)(host)}}catch(cause){return{connected:false,error:facadeError("GUI_FAILED","gui",componentKind,`${componentKind} "${state.id}" host connectivity check failed.`,state,cause)}}}function current(state,epoch){return!disconnected&&states.get(state.id)===state&&(epoch===void 0||state.life[1]===epoch)}function currentFilterCallback(state,callbackEpoch){return current(state)&&state.life[2]===callbackEpoch}function currentFloatingCallback(state,callbackEpoch){return current(state)&&state.life[3]===callbackEpoch}function currentFilterLookup(state){const lookup=manager.filter.runtime.lookup(state.fKey);return lookup.status==="mounted"&&lookup.generation===state.life[4]?lookup:void 0}function currentFloatingLookup(state){const lookup=manager.floatingFilter.runtime.lookup(state.ffKey);return lookup.status==="mounted"&&lookup.generation===state.life[5]?lookup:void 0}function invalidateActive(state){state.active=void 0;state.activeFailure=void 0}function markModelRestorePending(state){state.life[7]=true;state.active=true;state.activeFailure??=facadeError("MODEL_FAILED","model","filter",`Filter "${state.id}" is restoring its preserved model.`,state);return state.activeFailure}function clearExactModelRestoreLatch(state,epoch,generation,expectedError){if(!state.life[7]||state.activeFailure!==expectedError||!ownsExactFilterGeneration(state,epoch,generation)){return false}state.life[7]=false;invalidateActive(state);return true}function ownsExactFilterGeneration(state,epoch,generation){return current(state,epoch)&&currentFilterLookup(state)?.generation===generation}function readActive(state){if(state.active!==void 0){return state.activeFailure===void 0?{active:state.active}:{active:state.active,error:state.activeFailure}}const result=manager.filter.getActive(state.fKey);if(result.status==="ok"){state.active=result.value;state.activeFailure=void 0;return{active:result.value}}if(result.status==="failed"){state.active=true;state.activeFailure=result.error;return{active:true,error:result.error}}state.active=false;state.activeFailure=void 0;return{active:false}}function captureModelSync(state,errors){const lookup=currentFilterLookup(state);if(lookup===void 0)return state.model;try{const value=lookup.instance.getModel();state.model=value;state.life[8]=false;return value}catch(cause){const error=facadeError("MODEL_FAILED","model","filter",`Filter "${state.id}" failed to expose its model.`,state,cause);if(!state.life[8]){state.life[8]=true;report(error)}errors?.push(error);return state.model}}function notifyHostChanged(state,source){state.published=state.model;state.fingerprint=fingerprintModel(state.model);modelRevision+=1;try{options.onFilterChanged?.({colId:state.id,source,model:state.model,revision:modelRevision})}catch(cause){report(facadeError("MODEL_FAILED","model","filter",`Filter "${state.id}" change callback failed.`,state,cause))}}function propagateParentModel(state,source,force=false){if(currentFloatingLookup(state)===void 0){return Promise.resolve()}return manager.floatingFilter.parentModelChanged(state.ffKey,state.model,source,force).then(()=>void 0).catch(()=>void 0)}function notifyPeers(changed){return Promise.all([...states.values()].filter(state=>state!==changed&&currentFilterLookup(state)!==void 0).map(state=>manager.filter.onAnyFilterChanged(state.fKey).catch(()=>void 0))).then(()=>void 0)}function onFilterUiChanged(state,callbackEpoch,stillOwned){if(!currentFilterCallback(state,callbackEpoch)||!stillOwned()||state.life[6]>0){return}invalidateActive(state);captureModelSync(state);void propagateParentModel(state,"ui");void notifyPeers(state);notifyHostChanged(state,"ui")}function onFilterModified(state,callbackEpoch,stillOwned){if(!currentFilterCallback(state,callbackEpoch)||!stillOwned()||state.life[6]>0){return}try{options.onFilterModified?.(state.id)}catch(cause){report(facadeError("MODEL_FAILED","model","filter",`Filter "${state.id}" modified callback failed.`,state,cause))}}function filterParams(state,callbackEpoch,stillOwned){return{colId:state.id,context:state.ctx,getValue:state.valueOf,filterChangedCallback:()=>onFilterUiChanged(state,callbackEpoch,stillOwned),filterModifiedCallback:()=>onFilterModified(state,callbackEpoch,stillOwned),signal:lifecycleController.signal}}function floatingParams(state,owner,stillOwned=()=>true){return{colId:state.id,context:state.ctx,parentModel:state.model,onModelChange:next=>{if(!currentFloatingCallback(state,owner[3])||!stillOwned()||!latestIntentRetains(owner[4],owner[5],true)){return}void enqueue(()=>setFilterModelInternal(state,next,"ui",0,void 0,owner))},signal:lifecycleController.signal}}async function resolveFilter(state,source,epoch,local){const name=declarationName(source);const resolved=typeof source==="string"?await manager.resolve({kind:"filter",name,local,signal:state.life[0].signal}):await manager.resolve({kind:"filter",definition:source,local,signal:state.life[0].signal});if(!current(state,epoch))return void 0;state.fName=resolved.name;return resolved.definition}async function resolveFloating(state,source,epoch,stillOwned){if(!stillOwned())return void 0;const name=declarationName(source);const resolved=typeof source==="string"?await manager.resolve({kind:"floatingFilter",name,local:state.defs,signal:state.life[0].signal}):await manager.resolve({kind:"floatingFilter",definition:source,local:state.defs,signal:state.life[0].signal});if(!current(state,epoch)||!stillOwned())return void 0;state.ffName=resolved.name;return resolved.definition}async function detachInternal(state,floating=false){const attachmentProperty=floating?"floatingAttach":"filterAttach";const attachment=state[attachmentProperty];if(attachment===void 0){return{status:"already-detached",colId:state.id}}state[attachmentProperty]=void 0;const component=floating?manager.floatingFilter:manager.filter;const result=await component.afterDetach(floating?state.ffKey:state.fKey,attachment[2]);removeOwnedGui(attachment);if(!current(state)){return{status:"stale",colId:state.id}}if(result.status==="failed"){return{status:"failed",colId:state.id,error:result.error}}if(result.status==="stale"){return{status:"stale",colId:state.id}}return{status:"detached",colId:state.id}}async function attachInternal(state,host,floating=false,stillOwned=()=>true){if(!current(state)||!stillOwned()){return{status:"stale",colId:state.id}}const lookup=floating?currentFloatingLookup(state):currentFilterLookup(state);if(lookup===void 0){return{status:"not-mounted",colId:state.id}}const componentKind=floating?"floatingFilter":"filter";const component=floating?manager.floatingFilter:manager.filter;const componentKey=floating?state.ffKey:state.fKey;const attachmentProperty=floating?"floatingAttach":"filterAttach";const initialConnection=hostConnection(host,state,componentKind);if(!initialConnection.connected){if(initialConnection.error!==void 0){report(initialConnection.error);return{status:"failed",colId:state.id,error:initialConnection.error}}return{status:"detached-host",colId:state.id}}const existing=state[attachmentProperty];if(existing?.[0]===host&&existing[1]===lookup.gui&&existing[2]===lookup.generation){return{status:"already-attached",colId:state.id,generation:lookup.generation,gui:lookup.gui}}if(existing!==void 0){await detachInternal(state,floating);if(!current(state)||!stillOwned()){return{status:"stale",colId:state.id}}}try{if(typeof host.replaceChildren!=="function"){throw new TypeError("A custom-filter GUI host must implement replaceChildren().")}host.replaceChildren(lookup.gui)}catch(cause){const error=facadeError("GUI_FAILED","gui",componentKind,`${floating?"Floating filter":"Filter"} "${state.id}" GUI could not be inserted.`,state,cause);report(error);return{status:"failed",colId:state.id,error}}const attachment=[host,lookup.gui,lookup.generation];if(!stillOwned()){removeOwnedGui(attachment);return{status:"stale",colId:state.id}}state[attachmentProperty]=attachment;const attached=await component.afterAttach(componentKey,lookup.generation);const operationOwned=current(state)&&stillOwned();const settledConnection=!floating||operationOwned?hostConnection(host,state,componentKind):{connected:true,error:void 0};if(!operationOwned||state[attachmentProperty]!==attachment||!settledConnection.connected){if(state[attachmentProperty]===attachment){state[attachmentProperty]=void 0}await component.afterDetach(componentKey,lookup.generation);removeOwnedGui(attachment);if(settledConnection.error!==void 0){report(settledConnection.error);return{status:"failed",colId:state.id,error:settledConnection.error}}return{status:!settledConnection.connected&&(!floating||operationOwned)?"detached-host":"stale",colId:state.id}}if(attached.status!=="ok"){state[attachmentProperty]=void 0;removeOwnedGui(attachment);return attached.status==="failed"?{status:"failed",colId:state.id,error:attached.error}:{status:"stale",colId:state.id}}return{status:"attached",colId:state.id,generation:lookup.generation,gui:lookup.gui}}async function destroyFloatingInternal(state,stillOwned,generation=state.life[5]){const owned=()=>stillOwned?.()!==false;if(!owned())return false;state.life[3]+=1;const attachment=state.floatingAttach?.[2]===generation?state.floatingAttach:void 0;if(attachment!==void 0){state.floatingAttach=void 0;await manager.floatingFilter.afterDetach(state.ffKey,generation);removeOwnedGui(attachment);if(!owned())return false}const lookup=manager.floatingFilter.runtime.lookup(state.ffKey);if(lookup.status==="mounted"&&lookup.generation===generation){await manager.floatingFilter.destroy(state.ffKey)}if(state.life[5]===generation){state.floatingDef=void 0;state.life[5]=0;state.floatingAttach=void 0;state.ffName=void 0;state.floatingOwner=void 0}return owned()}async function latchModelRestoreFailure(state,error,preservedModel,failedGeneration,epoch){if(!current(state,epoch))return;state.model=preservedModel;state.life[7]=true;state.active=true;state.activeFailure=error;state.life[2]+=1;if(state.filterAttach!==void 0){await detachInternal(state)}if(!current(state,epoch))return;const failedLookup=manager.filter.runtime.lookup(state.fKey);if(failedLookup.status==="mounted"&&failedLookup.generation===failedGeneration){await manager.filter.destroy(state.fKey)}if(!current(state,epoch))return;const settledLookup=manager.filter.runtime.lookup(state.fKey);if(settledLookup.status==="unmounted"){state.filterDef=void 0;state.life[4]=0;state.filterAttach=void 0}await destroyFloatingInternal(state)}async function destroyStateInternal(state){if(states.get(state.id)!==state)return false;states.delete(state.id);state.life[1]+=1;state.life[0].abort(new Error(`Filter "${state.id}" was destroyed.`));const filterAttachment=state.filterAttach;const floatingAttachment=state.floatingAttach;state.filterAttach=void 0;state.floatingAttach=void 0;if(filterAttachment!==void 0){await manager.filter.afterDetach(state.fKey,filterAttachment[2]);removeOwnedGui(filterAttachment)}if(floatingAttachment!==void 0){await manager.floatingFilter.afterDetach(state.ffKey,floatingAttachment[2]);removeOwnedGui(floatingAttachment)}await Promise.all([manager.filter.destroy(state.fKey),manager.floatingFilter.destroy(state.ffKey)]);return true}async function reconcileFloating(state,desired,paramsChanged,epoch,errors,stillOwned,forceResolve=false){if(!stillOwned())return;const retainedHost=state.floatingAttach?.[0]??state.pendingFloating;if(desired==null){state.pendingFloating=retainedHost;if(state.floatingDef!==void 0||currentFloatingLookup(state)!==void 0){if(!await destroyFloatingInternal(state,stillOwned))return}if(!stillOwned())return;state.floatingSrc=desired;state.pendingFloating=void 0;return}const sourceChanged=!Object.is(state.floatingSrc,desired)||forceResolve||state.floatingDef===void 0||currentFloatingLookup(state)===void 0;if(!sourceChanged&&!paramsChanged){rebindFloatingCallback(state,epoch,state.life[4]);return}let definition;try{definition=sourceChanged?await resolveFloating(state,desired,epoch,stillOwned):state.floatingDef}catch(cause){if(!stillOwned()||state.life[0].signal.aborted){return}const error=facadeError("COMPONENT_NOT_FOUND","lookup","floatingFilter",`Floating filter "${state.id}" could not be resolved.`,state,cause);report(error);errors.push(error);if((paramsChanged||forceResolve)&&stillOwned()){state.pendingFloating=retainedHost;await destroyFloatingInternal(state,stillOwned)}return}if(definition===void 0||!stillOwned()){return}state.pendingFloating=retainedHost;if(!await destroyFloatingInternal(state,stillOwned))return;const callbackEpoch=state.life[3];const callbackOwner=[epoch,state.life[4],0,callbackEpoch,{...reconcileColumnSnapshot(state),floatingFilter:desired},state.ctx];let callbackOwnershipReleased=false;const callbackOwned=()=>callbackOwnershipReleased||stillOwned();const mounted=await manager.floatingFilter.mount({key:state.ffKey,componentName:state.ffName,definition,params:floatingParams(state,callbackOwner,callbackOwned)});if(!stillOwned()){if(mounted.status==="mounted"){await destroyFloatingInternal(state,void 0,mounted.generation)}return}if(mounted.status!=="mounted"){if(mounted.status==="failed")errors.push(mounted.error);return}state.floatingDef=definition;state.floatingSrc=desired;state.life[5]=mounted.generation;callbackOwner[2]=mounted.generation;state.floatingOwner=callbackOwner;if(retainedHost!==void 0){const attached=await attachInternal(state,retainedHost,true,stillOwned);if(!stillOwned()){await destroyFloatingInternal(state,void 0,mounted.generation);return}if(attached.status==="attached"||attached.status==="already-attached"){state.pendingFloating=void 0}}else{state.pendingFloating=void 0}callbackOwnershipReleased=true}async function applyColumn(state,column,nextContext,reconcileRevision,errors){const desired=column.filter;if(desired==null)return"unchanged";const resolutionChanged=!Object.is(state.resolveVersion,column.resolutionVersion)||!Object.is(state.defs,column.local);const paramsChanged=!Object.is(state.valueOf,column.getValue)||!Object.is(state.defs,column.local)||!Object.is(state.version,column.version)||!Object.is(state.ctx,nextContext);const sourceChanged=!Object.is(state.filterSrc,desired)||resolutionChanged||state.filterDef===void 0||currentFilterLookup(state)===void 0;if(!sourceChanged&&!paramsChanged){if(reconcileRevision!==reconcileRequestRevision){return"stale"}const floatingEpoch=state.life[1];const floatingFilterGeneration=state.life[4];const floatingOwned=()=>filterOperationOwned(state,floatingEpoch,floatingFilterGeneration,column,nextContext,reconcileRevision);if(state.life[0].signal.aborted){state.life[0]=new AbortController}await reconcileFloating(state,column.floatingFilter,false,state.life[1],errors,floatingOwned,false);return reconcileRevision===reconcileRequestRevision?"unchanged":"stale"}state.life[0].abort(new Error(`Filter "${state.id}" reconciliation was superseded.`));state.life[0]=new AbortController;const lookupEpoch=state.life[1];let definition;try{definition=sourceChanged?await resolveFilter(state,desired,lookupEpoch,column.local):state.filterDef}catch(cause){if(!current(state,lookupEpoch)||reconcileRevision!==reconcileRequestRevision||state.life[0].signal.aborted){return"stale"}const error=facadeError("COMPONENT_NOT_FOUND","lookup","filter",`Filter "${state.id}" could not be resolved.`,state,cause);report(error);errors.push(error);if(resolutionChanged&&current(state,lookupEpoch)){await detachInternal(state);await manager.filter.destroy(state.fKey);state.filterDef=void 0;state.life[4]=0;await destroyFloatingInternal(state)}return"stale"}if(definition===void 0||!current(state,lookupEpoch)||reconcileRevision!==reconcileRequestRevision){return"stale"}state.life[1]+=1;const epoch=state.life[1];state.life[2]+=1;const filterCallbackEpoch=state.life[2];state.valueOf=column.getValue;state.defs=column.local;state.version=column.version;state.resolveVersion=column.resolutionVersion;state.ctx=nextContext;const previousLookup=currentFilterLookup(state);const retainedHost=state.filterAttach?.[0]??state.pendingFilter;state.pendingFilter=retainedHost;const preservedModel=captureModelSync(state);const restoreModelOnMount=state.life[7];if(state.filterAttach!==void 0){await detachInternal(state)}if(!current(state,epoch))return"stale";let callbackGeneration=state.life[4];const callbackOwned=()=>ownsExactFilterGeneration(state,epoch,callbackGeneration)&&latestIntentRetains(column,nextContext,false);const params=filterParams(state,filterCallbackEpoch,callbackOwned);let restoreLatchError=state.life[7]?state.activeFailure:void 0;if(previousLookup!==void 0&&sourceChanged){restoreLatchError=markModelRestorePending(state)}state.life[6]+=1;const result=await(async()=>{try{return previousLookup===void 0?await manager.filter.mount({key:state.fKey,componentName:state.fName,definition,params}):sourceChanged?await manager.filter.recreate(state.fKey,{componentName:state.fName,definition,params},{preserveModel:true}):await manager.filter.refresh(state.fKey,params)}finally{state.life[6]-=1}})();if(!current(state,epoch))return"stale";if(result.status==="failed"&&result.error.code==="MODEL_FAILED"){errors.push(result.error);await latchModelRestoreFailure(state,result.error,preservedModel,result.generation,epoch);return"stale"}if(reconcileRevision!==reconcileRequestRevision)return"stale";if(result.status==="failed"||result.status==="not-mounted"||result.status==="stale"){if(result.status==="failed")errors.push(result.error);state.filterDef=void 0;state.life[4]=0;await destroyFloatingInternal(state);return"stale"}callbackGeneration=result.generation;state.filterDef=definition;state.filterSrc=desired;state.life[4]=result.generation;if(result.status==="recreated"||previousLookup===void 0&&restoreModelOnMount){restoreLatchError=markModelRestorePending(state);state.life[6]+=1;try{const restored=await manager.filter.setModel(state.fKey,preservedModel);if(restored.status!=="ok"||restored.generation!==result.generation){const error=restored.status==="failed"?restored.error:facadeError("MODEL_FAILED","model","filter",`Filter "${state.id}" replacement could not restore its model.`,state,new Error(`Filter model restoration settled as "${restored.status}".`));if(restored.status!=="failed")report(error);errors.push(error);await latchModelRestoreFailure(state,error,preservedModel,result.generation,epoch);return"stale"}}finally{state.life[6]-=1}}if(!current(state,epoch))return"stale";const hadRestoreLatch=state.life[7];const finalizationOwned=()=>reconcileRevision===reconcileRequestRevision||hadRestoreLatch&&latestIntentRetains(column,nextContext,reconcileRevision);if(!finalizationOwned())return"stale";if(hadRestoreLatch&&(restoreLatchError===void 0||!clearExactModelRestoreLatch(state,epoch,result.generation,restoreLatchError))){return"stale"}if(!hadRestoreLatch)invalidateActive(state);const acceptedModel=captureModelSync(state,errors);const transition=comparePublishedModel(state,acceptedModel);const activity=readActive(state);if(activity.error!==void 0)errors.push(activity.error);if(retainedHost!==void 0&&finalizationOwned()){await attachInternal(state,retainedHost);if(finalizationOwned()){state.pendingFilter=void 0}}if(!finalizationOwned())return"stale";await reconcileFloating(state,column.floatingFilter,paramsChanged,epoch,errors,()=>filterOperationOwned(state,epoch,result.generation,column,nextContext,reconcileRevision),resolutionChanged);if(!finalizationOwned())return"stale";if((previousLookup!==void 0||hadRestoreLatch)&&transition.changed&&ownsExactFilterGeneration(state,epoch,result.generation)&&state.activeFailure===void 0&&finalizationOwned()){await Promise.all([propagateParentModel(state,"api",hadRestoreLatch),notifyPeers(state)]);if(ownsExactFilterGeneration(state,epoch,result.generation)&&state.activeFailure===void 0&&finalizationOwned()){notifyHostChanged(state,"api")}}if(reconcileRevision!==reconcileRequestRevision)return"stale";return previousLookup===void 0?"mounted":sourceChanged||result.status==="recreated"?"mounted":"refreshed"}function createState(column,nextContext){return{id:column.colId.trim(),fKey:filterKey(ownerId,column.colId.trim()),ffKey:floatingKey(ownerId,column.colId.trim()),life:[new AbortController,0,0,0,0,0,0,false,false],valueOf:column.getValue,defs:column.local,version:column.version,resolveVersion:column.resolutionVersion,ctx:nextContext,model:null,published:null,fingerprint:fingerprintModel(null)}}async function setFilterModelInternal(state,model,source,requestRevision,batchChangedStates,floatingOwner){if(!current(state)){return{status:"not-mounted",key:state.fKey}}const operationEpoch=floatingOwner?.[0]??state.life[1];const operationGeneration=floatingOwner?.[1]??state.life[4];const operationContext=floatingOwner?.[5]??state.ctx;const operationColumn=floatingOwner?.[4]??reconcileColumnSnapshot(state);const operationOwned=()=>floatingOwner===void 0?filterOperationOwned(state,operationEpoch,operationGeneration,operationColumn,operationContext,requestRevision):floatingCallbackOwned(state,floatingOwner);const staleResult=()=>({status:"stale",key:state.fKey,generation:operationGeneration});if(!operationOwned())return staleResult();state.life[6]+=1;let result;try{result=await manager.filter.setModel(state.fKey,model)}finally{state.life[6]-=1}if(result.status!=="ok"||!current(state))return result;if(!operationOwned())return staleResult();const accepted=await manager.filter.getModel(state.fKey);if(accepted.status!=="ok")return accepted;if(!operationOwned())return staleResult();state.life[8]=false;invalidateActive(state);readActive(state);const comparison=comparePublishedModel(state,accepted.value);state.model=accepted.value;if(comparison.changed||source==="ui"){if(batchChangedStates===void 0){await Promise.all([propagateParentModel(state,source),notifyPeers(state)])}else{await propagateParentModel(state,source);if(!operationOwned())return staleResult();batchChangedStates.add(state)}if(!operationOwned())return staleResult();notifyHostChanged(state,source)}return result}const controller={reconcileColumns(columns){const revision=++reconcileRequestRevision;const snapshot=columns.map(column=>({...column}));const requestContext=captureContext();latestReconcileIntent=captureReconcileIntent(revision,snapshot,requestContext);for(const state of states.values()){state.life[0].abort(new Error(`Filter reconciliation ${revision-1} was superseded by ${revision}.`))}return enqueue(async()=>{const mounted=[];const refreshed=[];const unchanged=[];const destroyed=[];const errors=[];if(disconnected){return{status:"disconnected",revision,mounted,refreshed,unchanged,destroyed,errors}}if(revision!==reconcileRequestRevision){return{status:"stale",revision,mounted,refreshed,unchanged,destroyed,errors}}const desired=new Map;for(const column of snapshot){const colId=column.colId.trim();if(!colId){const error=facadeError("INVALID_NAME","lookup","filter","Custom-filter colId must be a non-empty string.",void 0);report(error);errors.push(error);continue}if(desired.has(colId)){const error=facadeError("INVALID_NAME","lookup","filter",`Custom-filter colId "${colId}" is duplicated.`,states.get(colId));report(error);errors.push(error);continue}if(column.filter!=null){desired.set(colId,{...column,colId})}}if(requestContext.status==="failed"){const error=facadeError("INIT_FAILED","init","filter","Custom-filter context could not be resolved.",void 0,requestContext.cause);report(error);errors.push(error);return{status:"applied",revision,mounted,refreshed,unchanged,destroyed,errors}}const nextContext=requestContext.value;for(const[colId,state]of[...states]){if(!desired.has(colId)){if(await destroyStateInternal(state))destroyed.push(colId)}}for(const[colId,column]of desired){if(disconnected||revision!==reconcileRequestRevision){return{status:disconnected?"disconnected":"stale",revision,mounted,refreshed,unchanged,destroyed,errors}}let state=states.get(colId);if(state===void 0){state=createState(column,nextContext);states.set(colId,state)}const result=await applyColumn(state,column,nextContext,revision,errors);if(result==="mounted")mounted.push(colId);if(result==="refreshed")refreshed.push(colId);if(result==="unchanged")unchanged.push(colId)}if(disconnected||revision!==reconcileRequestRevision){return{status:disconnected?"disconnected":"stale",revision,mounted,refreshed,unchanged,destroyed,errors}}appliedReconcileRevision=revision;return{status:"applied",revision,mounted,refreshed,unchanged,destroyed,errors}})},attachFilterGui(colId,host){return enqueue(async()=>{if(disconnected){return{status:"disconnected",colId}}const state=states.get(colId);if(state===void 0){return{status:"not-mounted",colId}}const attached=await attachInternal(state,host);state.pendingFilter=void 0;return attached})},detachFilterGui(colId){return enqueue(async()=>{if(disconnected){return{status:"disconnected",colId}}const state=states.get(colId);if(state===void 0){return{status:"already-detached",colId}}state.pendingFilter=void 0;return detachInternal(state)})},attachFloatingFilterGui(colId,host){return enqueue(async()=>{if(disconnected){return{status:"disconnected",colId}}const state=states.get(colId);if(state===void 0){return{status:"not-mounted",colId}}const attached=await attachInternal(state,host,true);if(attached.status==="attached"||attached.status==="already-attached"){state.pendingFloating=void 0}return attached})},detachFloatingFilterGui(colId){return enqueue(async()=>{if(disconnected){return{status:"disconnected",colId}}const state=states.get(colId);if(state===void 0){return{status:"already-detached",colId}}state.pendingFloating=void 0;return detachInternal(state,true)})},doesPass(data,suppliedMode){if(disconnected||(suppliedMode??mode())!=="client"){return true}for(const state of states.values()){const activeResult=readActive(state);if(activeResult.error!==void 0)return false;if(activeResult.active&&!manager.filter.doesPass(state.fKey,data)){return false}}const external=manager.getExternalFilter();if(external===null)return true;if(external.getPredicateError()!==null)return false;const present=external.isPresent();if(external.getPredicateError()!==null)return false;if(!present)return true;const passes=external.doesPass(data);return external.getPredicateError()===null&&passes},isFilterActive(colId){const state=states.get(colId);if(state===void 0)return false;return readActive(state).active},onAnyFilterChanged(exceptColId){return enqueue(async()=>Promise.all([...states.values()].filter(state=>state.id!==exceptColId&&currentFilterLookup(state)!==void 0).map(state=>manager.filter.onAnyFilterChanged(state.fKey))))},synchronizeFilterModels(source="api"){const requestRevision=reconcileRequestRevision;return enqueue(async()=>{const results=[];const changedStates=[];for(const state of states.values()){const operationEpoch=state.life[1];const operationGeneration=state.life[4];const operationContext=state.ctx;const operationColumn=reconcileColumnSnapshot(state);const owned=()=>filterOperationOwned(state,operationEpoch,operationGeneration,operationColumn,operationContext,requestRevision);const staleResult=()=>({status:"stale",key:state.fKey,generation:operationGeneration});if(!owned()){results.push(staleResult());continue}const result=await manager.filter.getModel(state.fKey);if(result.status!=="ok"){results.push(result);continue}if(!owned()){results.push(staleResult());continue}const comparison=comparePublishedModel(state,result.value);state.model=result.value;if(!comparison.changed){results.push(result);continue}state.life[8]=false;invalidateActive(state);readActive(state);await propagateParentModel(state,source,true);if(!owned()){results.push(staleResult());continue}notifyHostChanged(state,source);changedStates.push({state,owned});results.push(result)}if(changedStates.some(({owned})=>owned())){await Promise.all([...states.values()].filter(state=>currentFilterLookup(state)!==void 0&&operationIntentOwned(reconcileColumnSnapshot(state),state.ctx,requestRevision)).map(state=>manager.filter.onAnyFilterChanged(state.fKey)))}return results})},getSerializableModels(){const models=Object.create(null);const errors=[];for(const colId of[...states.keys()].sort()){const state=states.get(colId);const activeResult=readActive(state);if(activeResult.error!==void 0){errors.push(activeResult.error);continue}if(!activeResult.active)continue;const value=captureModelSync(state,errors);try{models[colId]=canonicalizeSerializable(value,new Set,`filterModel.${colId}`,0)}catch(cause){const error=facadeError("MODEL_FAILED","model","filter",`Filter "${colId}" returned a non-serializable model.`,state,cause);report(error);errors.push(error)}}return{revision:modelRevision,models:Object.freeze(models),errors:Object.freeze(errors)}},getFilterModels(){return enqueue(async()=>{const models=Object.create(null);const errors=[];for(const colId of[...states.keys()].sort()){const state=states.get(colId);const result=await manager.filter.getModel(state.fKey);if(result.status==="ok"){state.model=result.value;models[colId]=result.value}else if(result.status==="failed"){errors.push(result.error)}}return{revision:modelRevision,models:Object.freeze(models),errors:Object.freeze(errors)}})},getFilterModel(colId){return enqueue(async()=>{const state=states.get(colId);if(state===void 0){return{status:"not-mounted",key:filterKey(ownerId,colId)}}const result=await manager.filter.getModel(state.fKey);if(result.status==="ok")state.model=result.value;return result})},setFilterModel(colId,modelValue,source="api"){const requestRevision=reconcileRequestRevision;return enqueue(async()=>{const state=states.get(colId);return state===void 0?{status:"not-mounted",key:filterKey(ownerId,colId)}:setFilterModelInternal(state,modelValue,source,requestRevision)})},setFilterModels(models,setOptions){const requestRevision=reconcileRequestRevision;return enqueue(async()=>{const results=[];const changedStates=new Set;const source=setOptions?.source??"api";const clearUnspecified=setOptions?.clearUnspecified??true;for(const state of states.values()){const hasModel=Object.prototype.hasOwnProperty.call(models,state.id);if(!hasModel&&!clearUnspecified)continue;results.push(await setFilterModelInternal(state,hasModel?models[state.id]:null,source,requestRevision,changedStates))}if(changedStates.size>0){await Promise.all([...states.values()].filter(state=>currentFilterLookup(state)!==void 0&&(changedStates.size>1||!changedStates.has(state))).map(state=>manager.filter.onAnyFilterChanged(state.fKey).catch(()=>void 0)))}return results})},destroyFilter(colId){return enqueue(async()=>{const state=states.get(colId);return state===void 0?false:destroyStateInternal(state)})},recreateFilter(colId,recreateOptions){const requestRevision=reconcileRequestRevision;return enqueue(async()=>{if(disconnected){return{status:"disconnected",colId}}const state=states.get(colId);if(state===void 0||state.filterDef===void 0){return{status:"not-mounted",colId}}const operationEpoch=state.life[1];const operationContext=state.ctx;const operationColumn=reconcileColumnSnapshot(state);const intentOwned=()=>current(state,operationEpoch)&&operationIntentOwned(operationColumn,operationContext,requestRevision);const staleResult=()=>({status:"stale",colId});if(!intentOwned())return staleResult();const previousModel=captureModelSync(state);const retainedHost=state.filterAttach?.[0]??state.pendingFilter;state.pendingFilter=retainedHost;state.life[2]+=1;const callbackEpoch=state.life[2];let callbackGeneration=state.life[4];const callbackOwned=()=>ownsExactFilterGeneration(state,operationEpoch,callbackGeneration)&&latestIntentRetains(operationColumn,operationContext,false);await detachInternal(state);if(!intentOwned())return staleResult();let restoreLatchError;if(recreateOptions?.preserveModel??true){restoreLatchError=markModelRestorePending(state)}state.life[6]+=1;const result=await(async()=>{try{return await manager.filter.recreate(state.fKey,{componentName:state.fName,definition:state.filterDef,params:filterParams(state,callbackEpoch,callbackOwned)},recreateOptions)}finally{state.life[6]-=1}})();if(!intentOwned())return staleResult();if(result.status!=="mounted"){const error=result.status==="failed"?result.error:facadeError("MODEL_FAILED","model","filter",`Filter "${state.id}" recreation could not preserve its model.`,state,new Error(`Filter recreation settled as "${result.status}".`));if(result.status!=="failed")report(error);await latchModelRestoreFailure(state,error,previousModel,result.status==="not-mounted"?state.life[4]:result.generation,state.life[1]);return result.status==="failed"?{status:"failed",colId,error:result.error}:{status:"stale",colId}}callbackGeneration=result.generation;state.life[4]=result.generation;const finalizationOwned=()=>intentOwned()&&ownsExactFilterGeneration(state,operationEpoch,result.generation);if(!finalizationOwned())return staleResult();rebindFloatingCallback(state,operationEpoch,result.generation);if(restoreLatchError===void 0){invalidateActive(state)}else if(!clearExactModelRestoreLatch(state,state.life[1],result.generation,restoreLatchError)){return{status:"stale",colId}}const acceptedModel=captureModelSync(state);const transition=comparePublishedModel(state,acceptedModel);readActive(state);if(!finalizationOwned())return staleResult();if(transition.changed){await Promise.all([propagateParentModel(state,"api"),notifyPeers(state)]);if(finalizationOwned()){notifyHostChanged(state,"api")}else{return staleResult()}}if(!finalizationOwned())return staleResult();if(retainedHost!==void 0){const attached=await attachInternal(state,retainedHost);if(!finalizationOwned()){await detachInternal(state);return staleResult()}state.pendingFilter=void 0;return attached}return{status:"mounted",colId,generation:result.generation,gui:result.gui}})},lookupFilterInstance(colId){const state=states.get(colId);return state===void 0?{status:"unmounted",key:filterKey(ownerId,colId)}:manager.filter.runtime.lookup(state.fKey)},lookupFloatingFilterInstance(colId){const state=states.get(colId);return state===void 0?{status:"unmounted",key:floatingKey(ownerId,colId)}:manager.floatingFilter.runtime.lookup(state.ffKey)},setExternalFilter(source){return enqueue(async()=>disconnected?null:manager.setExternalFilter(source))},refreshExternalFilter(suppliedContext){return enqueue(async()=>{if(disconnected)return null;const external=manager.getExternalFilter();return external?.refresh(suppliedContext??context(),{signal:lifecycleController.signal})??null})},getExternalFilter(){return manager.getExternalFilter()},onNewRowsLoaded(){return enqueue(async()=>{const results=[];for(const state of states.values()){results.push(await manager.filter.onNewRowsLoaded(state.fKey))}return results})},stats(){let mountedFilters=0;let mountedFloatingFilters=0;let attachedFilterGuis=0;let attachedFloatingFilterGuis=0;for(const state of states.values()){if(currentFilterLookup(state)!==void 0)mountedFilters+=1;if(currentFloatingLookup(state)!==void 0){mountedFloatingFilters+=1}if(state.filterAttach!==void 0){attachedFilterGuis+=1}if(state.floatingAttach!==void 0){attachedFloatingFilterGuis+=1}}return{columns:states.size,mountedFilters,mountedFloatingFilters,attachedFilterGuis,attachedFloatingFilterGuis,modelRevision,reconcileRevision:appliedReconcileRevision,disconnected}},disconnect(){if(disconnectTask!==void 0)return disconnectTask;disconnected=true;reconcileRequestRevision+=1;lifecycleController.abort(new Error("Grid filter facade disconnected."));for(const state of states.values()){state.life[0].abort(new Error("Grid filter facade disconnected."))}disconnectTask=enqueue(async()=>{const retained=[...states.values()];for(const state of retained){await destroyStateInternal(state)}await manager.setExternalFilter(null)});return disconnectTask}};return controller}

package/dist/collection/components/grid/core/component/framework-bridge.js

@@ -0,0 +1 @@
+import{GridComponentError}from"./contracts.js";function frameworkError(params,cause){return cause instanceof GridComponentError?cause:new GridComponentError("Framework component bridge failed.",{code:"FRAMEWORK_FAILED",phase:"framework",componentKind:params?.componentKind??"renderer",mountKey:params?.instanceId,retryable:true,cause})}const FRAMEWORK_HANDLE_OWNERS=new WeakMap;const FRAMEWORK_HANDLE_TOMBSTONES=new WeakSet;const FRAMEWORK_HANDLE_DESTROY_TASKS=new WeakMap;let frameworkHandleToken=0;function invalidFrameworkHandle(params){return new GridComponentError("Framework bridge returned a reused lifecycle handle.",{code:"INVALID_INSTANCE",phase:"framework",componentKind:params.componentKind,mountKey:params.instanceId,retryable:true})}function attachFrameworkCleanupCause(primary,cleanup){return new GridComponentError(primary.message,{code:primary.code,phase:primary.phase,componentKind:primary.componentKind,componentName:primary.componentName,mountKey:primary.mountKey,generation:primary.generation,retryable:primary.retryable,cause:new AggregateError([primary.cause??primary,cleanup],"Framework handle validation failed and retirement also failed.")})}class FrameworkLifecycle{params;handle;gui;handleClaim;destroyPromise;destroyed=false;component;bridge;constructor(component,bridge){this.component=component;this.bridge=bridge}async init(params){if(this.destroyed){throw frameworkError(params,new Error("Framework component was destroyed before mount."))}this.params=params;try{const candidate=await this.bridge.mount(this.component,params,params.signal);if(candidate===null||typeof candidate!=="object"){throw new TypeError("Framework bridge must return a non-null handle object.")}const handle=candidate;const claim=this.claimHandle(candidate,params);let gui;try{if(!("gui"in candidate)){throw new TypeError("Framework bridge handle must expose gui.")}gui=candidate.gui}catch(cause){return this.retireInvalidHandle(candidate,params,claim,cause)}if(this.destroyed||params.signal.aborted){await this.destroyHandle(handle,params,claim);throw new Error("Framework component mount settled after teardown.")}this.handle=handle;this.gui=gui;this.handleClaim=claim}catch(cause){throw frameworkError(params,cause)}}getGui(){if(this.handle===void 0||this.destroyed){throw frameworkError(this.params,new Error("Framework component is not mounted."))}return this.gui}async refresh(params){const handle=this.handle;if(handle===void 0||this.destroyed){return false}try{const update=handle.update;if(update!==void 0&&typeof update!=="function"){throw new TypeError("Framework handle update must be a function when provided.")}if(typeof update!=="function"||this.destroyed||this.handle!==handle||params.signal.aborted){return false}const result=await update.call(handle,params);if(this.destroyed||this.handle!==handle||params.signal.aborted){return false}if(result!==void 0&&typeof result!=="boolean"){throw new TypeError("Framework handle update must return boolean or void.")}if(result===false)return false;this.params=params;return true}catch(cause){if(this.destroyed||this.handle!==handle||params.signal.aborted){return false}throw frameworkError(params,cause)}}focusIn(){this.focus("in")}focusOut(){this.focus("out")}destroy(){this.destroyed=true;this.destroyPromise??=(async()=>{const handle=this.handle;const claim=this.handleClaim;const params=this.params;this.handle=void 0;this.gui=void 0;this.handleClaim=void 0;this.params=void 0;if(handle!==void 0&&claim!==void 0){await this.destroyHandle(handle,params,claim)}})();return this.destroyPromise}claimHandle(handle,params){const identity=handle;if(FRAMEWORK_HANDLE_TOMBSTONES.has(identity)||FRAMEWORK_HANDLE_OWNERS.has(identity)){throw invalidFrameworkHandle(params)}const claim={token:++frameworkHandleToken};FRAMEWORK_HANDLE_OWNERS.set(identity,claim);return claim}focus(direction){const handle=this.handle;if(handle===void 0||this.destroyed)return;const hook=direction==="in"?handle.focusIn:handle.focusOut;if(hook!==void 0&&typeof hook!=="function"){if(this.destroyed||this.handle!==handle)return;throw frameworkError(this.params,new TypeError(`Framework handle focus${direction==="in"?"In":"Out"} must be a function when provided.`))}if(typeof hook!=="function"||this.destroyed||this.handle!==handle||this.params?.signal.aborted){return}try{hook.call(handle)}catch(cause){if(this.destroyed||this.handle!==handle)return;throw frameworkError(this.params,cause)}}async retireInvalidHandle(handle,params,claim,cause){const primary=frameworkError(params,cause);try{await this.destroyHandle(handle,params,claim)}catch(cleanupCause){throw attachFrameworkCleanupCause(primary,cleanupCause)}throw primary}destroyHandle(handle,params,claim){const identity=handle;if(FRAMEWORK_HANDLE_OWNERS.get(identity)!==claim){return FRAMEWORK_HANDLE_DESTROY_TASKS.get(identity)??Promise.resolve()}const existing=FRAMEWORK_HANDLE_DESTROY_TASKS.get(identity);if(existing!==void 0)return existing;FRAMEWORK_HANDLE_OWNERS.delete(identity);FRAMEWORK_HANDLE_TOMBSTONES.add(identity);const task=(async()=>{try{const destroy=handle.destroy;if(typeof destroy!=="function")return;await destroy.call(handle)}catch(cause){throw frameworkError(params,cause)}})();FRAMEWORK_HANDLE_DESTROY_TASKS.set(identity,task);return task}}export function adaptGridFrameworkComponent(component,bridge){return{type:"factory",create:()=>new FrameworkLifecycle(component,bridge)}}

package/dist/collection/components/grid/core/component/index.js

@@ -0,0 +1 @@
+export*from"./contracts.js";export*from"./registry.js";export*from"./runtime.js";export*from"./renderer-adapter.js";export*from"./renderer-controller.js";export*from"./editor-adapter.js";export*from"./editor-validation-presentation.js";export*from"./filter-adapter.js";export*from"./framework-bridge.js";export*from"./async-value-source.js";export*from"./popup-placement.js";export*from"./rich-select-editor.js";

package/dist/collection/components/grid/core/component/popup-placement.js

@@ -0,0 +1 @@
+function finite(value,fallback=0){return Number.isFinite(value)?value:fallback}function clamp(value,lower,upper){if(upper<lower)return lower;return Math.min(Math.max(value,lower),upper)}export function placeGridEditorPopup(anchor,popup,viewport,options={}){const margin=Math.max(0,finite(options.margin??8,8));const gap=Math.max(0,finite(options.gap??4,4));const viewportLeft=finite(viewport.left)+margin;const viewportTop=finite(viewport.top)+margin;const viewportRight=Math.max(viewportLeft,finite(viewport.right,viewportLeft)-margin);const viewportBottom=Math.max(viewportTop,finite(viewport.bottom,viewportTop)-margin);const maxWidth=Math.max(0,viewportRight-viewportLeft);const requestedWidth=Math.max(options.touch===true?44:0,finite(popup.width),finite(anchor.width));const width=Math.min(requestedWidth,maxWidth);const popupHeight=Math.max(0,finite(popup.height));const rawLeft=options.rtl===true?finite(anchor.right)-width:finite(anchor.left);const left=clamp(rawLeft,viewportLeft,viewportRight-width);const preferred=options.preferred??"over";if(preferred==="over"){const top=clamp(finite(anchor.top),viewportTop,viewportBottom);const maxHeight=Math.max(0,viewportBottom-top);return{position:"fixed",placement:"over",left,top,width,maxWidth,maxHeight}}const belowTop=finite(anchor.bottom)+gap;const underTop=Math.max(viewportTop,belowTop);const aboveBottom=finite(anchor.top)-gap;const belowSpace=Math.max(0,viewportBottom-underTop);const aboveSpace=Math.max(0,aboveBottom-viewportTop);const useAbove=belowSpace<popupHeight&&aboveSpace>belowSpace;if(useAbove){const maxHeight=aboveSpace;const visibleHeight=Math.min(popupHeight,maxHeight);return{position:"fixed",placement:"above",left,top:Math.max(viewportTop,aboveBottom-visibleHeight),width,maxWidth,maxHeight}}return{position:"fixed",placement:"under",left,top:underTop,width,maxWidth,maxHeight:belowSpace}}

package/dist/collection/components/grid/core/component/registry.js

@@ -0,0 +1 @@
+import{GridComponentError}from"./contracts.js";function createKindStore(){return{renderer:new Map,editor:new Map,filter:new Map,floatingFilter:new Map}}function normalizeName(name,kind){if(typeof name!=="string"||name.trim().length===0){throw new GridComponentError(`${kind} component name must be a non-empty string.`,{code:"INVALID_NAME",phase:"lookup",componentKind:kind,retryable:false})}return name.trim()}function isRecord(value){return value!==null&&typeof value==="object"}function hasOwn(value,key){return Object.prototype.hasOwnProperty.call(value,key)}export function isGridEagerComponentDefinition(value){if(!isRecord(value))return false;try{if(value.type==="factory"){return typeof value.create==="function"}if(value.type==="class"){return typeof value.component==="function"}return false}catch{return false}}export function isGridLazyComponentDefinition(value){if(!isRecord(value))return false;try{return value.type==="lazy"&&typeof value.load==="function"}catch{return false}}function assertDefinition(value,kind,name){let captured;try{captured=captureGridComponentDefinition(value)}catch(cause){throw new GridComponentError(`${kind} component "${name??"<direct>"}" has an invalid definition.`,{code:"LAZY_INVALID_DEFINITION",phase:"lookup",componentKind:kind,componentName:name,retryable:false,cause})}if(captured!==void 0)return captured;throw new GridComponentError(`${kind} component "${name??"<direct>"}" has an invalid definition.`,{code:"LAZY_INVALID_DEFINITION",phase:"lookup",componentKind:kind,componentName:name,retryable:false})}const CAPTURED_EAGER_DEFINITIONS=new WeakMap;function rememberCapturedEager(source,captured){CAPTURED_EAGER_DEFINITIONS.set(source,captured)}export function getCapturedGridEagerDefinition(definition){return CAPTURED_EAGER_DEFINITIONS.get(definition)??definition}function captureGridComponentDefinition(value){if(!isRecord(value))return void 0;const type=value.type;if(type==="factory"){const create=value.create;if(typeof create!=="function")return void 0;return{type:"eager",definition:{type:"factory",create:context=>create.call(value,context)}}}if(type==="class"){const component=value.component;if(typeof component!=="function")return void 0;return{type:"eager",definition:{type:"class",component}}}if(type==="lazy"){const load=value.load;if(typeof load!=="function")return void 0;return{type:"lazy",load:context=>Promise.resolve(load.call(value,context))}}return void 0}function abortedError(kind,name,cause){return new GridComponentError(`${kind} component "${name??"<direct>"}" loading was aborted.`,{code:"ABORTED",phase:"lazy-load",componentKind:kind,componentName:name,retryable:true,cause})}async function waitForLazyResult(promise,signal,kind,name){if(!signal)return promise;if(signal.aborted)throw abortedError(kind,name,signal.reason);let onAbort;const abort=new Promise((_resolve,reject)=>{onAbort=()=>reject(abortedError(kind,name,signal.reason));signal.addEventListener("abort",onAbort,{once:true})});try{return await Promise.race([promise,abort])}finally{if(onAbort)signal.removeEventListener("abort",onAbort)}}export async function resolveGridComponentDefinition(definition,options){let captured;try{captured=captureGridComponentDefinition(definition)}catch(cause){throw new GridComponentError(`${options.kind} component "${options.name??"<direct>"}" has an invalid definition.`,{code:"LAZY_INVALID_DEFINITION",phase:"lazy-load",componentKind:options.kind,componentName:options.name,retryable:false,cause})}if(captured?.type==="eager"){rememberCapturedEager(definition,captured.definition);return definition}if(captured?.type!=="lazy"){throw new GridComponentError(`${options.kind} component "${options.name??"<direct>"}" has an invalid definition.`,{code:"LAZY_INVALID_DEFINITION",phase:"lazy-load",componentKind:options.kind,componentName:options.name,retryable:false})}if(options.signal?.aborted){throw abortedError(options.kind,options.name,options.signal.reason)}const rawLoad=Promise.resolve().then(()=>options.signal?.aborted?Promise.reject(abortedError(options.kind,options.name,options.signal.reason)):captured.load({componentKind:options.kind,componentName:options.name,signal:options.signal??new AbortController().signal}));void rawLoad.catch(()=>void 0);let loaded;try{loaded=await waitForLazyResult(rawLoad,options.signal,options.kind,options.name)}catch(error){if(error instanceof GridComponentError)throw error;throw new GridComponentError(`${options.kind} component "${options.name??"<direct>"}" failed to load.`,{code:"LAZY_LOAD_FAILED",phase:"lazy-load",componentKind:options.kind,componentName:options.name,retryable:true,cause:error})}let loadedDefinition;try{loadedDefinition=captureGridComponentDefinition(loaded)}catch(cause){throw new GridComponentError(`${options.kind} component "${options.name??"<direct>"}" loader returned an invalid definition.`,{code:"LAZY_INVALID_DEFINITION",phase:"lazy-load",componentKind:options.kind,componentName:options.name,retryable:true,cause})}if(loadedDefinition?.type!=="eager"){throw new GridComponentError(`${options.kind} component "${options.name??"<direct>"}" loader returned an invalid definition.`,{code:"LAZY_INVALID_DEFINITION",phase:"lazy-load",componentKind:options.kind,componentName:options.name,retryable:true})}rememberCapturedEager(loaded,loadedDefinition.definition);return loaded}function localLookup(local,kind,name){const group=local?.[kind];if(!group||!hasOwn(group,name)){return{found:false,value:void 0}}return{found:true,value:group[name]}}function lazyContextKey(kind,name){return JSON.stringify([kind,name??null])}export function createGridComponentRegistry(){const stores={local:createKindStore(),global:createKindStore()};let lazyContexts=new WeakMap;const activeLazyFlights=new Set;function removeEmptyLazyContext(definition,contexts,key,entry){if(entry.cached||entry.flight)return;if(contexts.get(key)!==entry)return;contexts.delete(key);if(contexts.size===0&&lazyContexts.get(definition)===contexts){lazyContexts.delete(definition)}}function abortLazyFlight(flight,reason){if(flight.settled||flight.invalidated)return;flight.invalidated=true;flight.controller.abort(reason)}function invalidateLazyContext(definition,kind,name,reason){const contexts=lazyContexts.get(definition);if(!contexts)return false;const key=lazyContextKey(kind,name);const entry=contexts.get(key);if(!entry)return false;const flight=entry.flight;const hadResolution=Boolean(entry.cached||flight);contexts.delete(key);if(contexts.size===0&&lazyContexts.get(definition)===contexts){lazyContexts.delete(definition)}if(flight)abortLazyFlight(flight,reason);return hadResolution}function createLazyFlight(definition,kind,name,contexts,key,entry){const controller=new AbortController;let flight;const promise=resolveGridComponentDefinition(definition,{kind,name,signal:controller.signal}).then(eager=>{flight.settled=true;activeLazyFlights.delete(flight);if(flight.invalidated||controller.signal.aborted||entry.flight!==flight){throw abortedError(kind,name,controller.signal.reason)}entry.flight=void 0;entry.cached=eager;return eager},error=>{flight.settled=true;activeLazyFlights.delete(flight);if(entry.flight===flight){entry.flight=void 0;removeEmptyLazyContext(definition,contexts,key,entry)}throw error});flight={controller,promise,waiters:new Set,settled:false,invalidated:false};activeLazyFlights.add(flight);void promise.catch(()=>void 0);return flight}async function resolveLazyDefinition(definition,kind,name,signal){if(signal?.aborted){throw abortedError(kind,name,signal.reason)}let contexts=lazyContexts.get(definition);if(!contexts){contexts=new Map;lazyContexts.set(definition,contexts)}const key=lazyContextKey(kind,name);let entry=contexts.get(key);if(!entry){entry={cached:void 0,flight:void 0};contexts.set(key,entry)}if(entry.cached)return entry.cached;const flight=entry.flight??createLazyFlight(definition,kind,name,contexts,key,entry);entry.flight=flight;const waiter=Symbol("grid-component-lazy-waiter");flight.waiters.add(waiter);try{return await waitForLazyResult(flight.promise,signal,kind,name)}finally{flight.waiters.delete(waiter);if(!flight.settled&&!flight.invalidated&&flight.waiters.size===0&&entry.flight===flight){entry.flight=void 0;removeEmptyLazyContext(definition,contexts,key,entry);abortLazyFlight(flight,signal?.reason??new Error(`${kind} component "${name??"<direct>"}" has no active waiters.`))}}}function register(scope,kind,rawName,definition){const name=normalizeName(rawName,kind);assertDefinition(definition,kind,name);const store=stores[scope][kind];if(store.has(name)){throw new GridComponentError(`${scope} ${kind} component "${name}" is already registered.`,{code:"DUPLICATE_COMPONENT",phase:"lookup",componentKind:kind,componentName:name,retryable:true})}store.set(name,definition)}function replace(scope,kind,rawName,definition){const name=normalizeName(rawName,kind);const store=stores[scope][kind];if(!store.has(name)){throw new GridComponentError(`${scope} ${kind} component "${name}" cannot be replaced because it is not registered.`,{code:"COMPONENT_NOT_FOUND",phase:"lookup",componentKind:kind,componentName:name,retryable:true})}assertDefinition(definition,kind,name);const previous=store.get(name);store.set(name,definition);if(isGridLazyComponentDefinition(previous)){invalidateLazyContext(previous,kind,name,new Error(`${scope} ${kind} component "${name}" was replaced.`))}}function unregister(scope,kind,rawName){const name=normalizeName(rawName,kind);const store=stores[scope][kind];const previous=store.get(name);const removed=store.delete(name);if(isGridLazyComponentDefinition(previous)){invalidateLazyContext(previous,kind,name,new Error(`${scope} ${kind} component "${name}" was unregistered.`))}return removed}async function resolve(request){const suppliedName=typeof request.name==="string"&&request.name.trim().length>0?request.name.trim():void 0;let candidate;let origin="direct";let name=suppliedName;let found=false;if(hasOwn(request,"definition")){candidate=request.definition;found=true}else{name=normalizeName(request.name,request.kind);const requestLocal=localLookup(request.local,request.kind,name);if(requestLocal.found){candidate=requestLocal.value;origin="local";found=true}else if(stores.local[request.kind].has(name)){candidate=stores.local[request.kind].get(name);origin="local";found=true}else if(stores.global[request.kind].has(name)){candidate=stores.global[request.kind].get(name);origin="global";found=true}}if(!found){throw new GridComponentError(`${request.kind} component "${name??"<direct>"}" was not found.`,{code:"COMPONENT_NOT_FOUND",phase:"lookup",componentKind:request.kind,componentName:name,retryable:true})}const captured=assertDefinition(candidate,request.kind,name);let eager;if(captured.type==="lazy"){eager=await resolveLazyDefinition(candidate,request.kind,name,request.signal)}else{rememberCapturedEager(candidate,captured.definition);eager=candidate}return{kind:request.kind,name,origin,definition:eager}}return{register,replace,unregister,has(scope,kind,rawName){const name=normalizeName(rawName,kind);return stores[scope][kind].has(name)},list(scope,kind){return[...stores[scope][kind].keys()]},resolve,invalidateLazy(scope,kind,rawName){const name=normalizeName(rawName,kind);const definition=stores[scope][kind].get(name);return isGridLazyComponentDefinition(definition)?invalidateLazyContext(definition,kind,name,new Error(`${scope} ${kind} component "${name}" lazy cache was invalidated.`)):false},clear(scope){if(!scope){const flights=[...activeLazyFlights];for(const selected of["local","global"]){for(const kind of["renderer","editor","filter","floatingFilter"]){stores[selected][kind].clear()}}lazyContexts=new WeakMap;for(const flight of flights){abortLazyFlight(flight,new Error("Grid component registry was cleared."))}return}const registrations=[];for(const kind of["renderer","editor","filter","floatingFilter"]){for(const[name,definition]of stores[scope][kind]){registrations.push([kind,name,definition])}stores[scope][kind].clear()}for(const[kind,name,definition]of registrations){if(isGridLazyComponentDefinition(definition)){invalidateLazyContext(definition,kind,name,new Error(`${scope} ${kind} component "${name}" was cleared.`))}}}}}

package/dist/collection/components/grid/core/component/renderer-adapter.js

@@ -0,0 +1 @@
+import{GridComponentError}from"./contracts.js";import{createGridComponentRuntime}from"./runtime.js";const CLAIMED_RENDERER_INSTANCES=new WeakSet;const RENDERER_DESTROY_TASKS=new WeakMap;function isRendererWeakKey(value){return value!==null&&(typeof value==="object"||typeof value==="function")}function invalidRendererInstance(instanceId,cause){return new GridComponentError(`Renderer "${instanceId}" returned a malformed or reused lifecycle instance.`,{code:"INVALID_INSTANCE",phase:"create",componentKind:"renderer",mountKey:instanceId,retryable:true,cause})}function destroyUnderlyingRenderer(instance,capturedDestroy,destroyWasCaptured=false){const existing=RENDERER_DESTROY_TASKS.get(instance);if(existing!==void 0)return existing;const task=Promise.resolve().then(()=>{const destroy=destroyWasCaptured?capturedDestroy:instance.destroy;if(typeof destroy!=="function")return;return destroy.call(instance)}).then(()=>void 0);RENDERER_DESTROY_TASKS.set(instance,task);return task}function captureRendererMethods(instance,onDestroyRead){let destroy;try{destroy=instance.destroy}catch(cause){onDestroyRead(void 0);throw cause}onDestroyRead(typeof destroy==="function"?destroy:void 0);if(destroy!==void 0&&typeof destroy!=="function"){throw new TypeError("Renderer destroy must be a function when provided.")}const rendererDestroy=destroy;const getGui=instance.getGui;if(typeof getGui!=="function"){throw new TypeError("Renderer getGui must be a function.")}const init=instance.init;const refresh=instance.refresh;const focusIn=instance.focusIn;const focusOut=instance.focusOut;for(const[name,method]of[["init",init],["refresh",refresh],["focusIn",focusIn],["focusOut",focusOut]]){if(method!==void 0&&typeof method!=="function"){throw new TypeError(`Renderer ${name} must be a function when provided.`)}}return{getGui,...init===void 0?{}:{init},...refresh===void 0?{}:{refresh},...focusIn===void 0?{}:{focusIn},...focusOut===void 0?{}:{focusOut},...rendererDestroy===void 0?{}:{destroy:rendererDestroy}}}function scopeRendererParams(params,lease){const setTooltip=params.setTooltip;const handoffFocus=params.handoffFocus;return{...params,setTooltip(value){if(lease.active)setTooltip(value)},handoffFocus(target){if(lease.active)handoffFocus(target)}}}function createScopedRendererInstance(instance,lease,methods){return{...methods.init===void 0?{}:{init(params){return methods.init.call(instance,scopeRendererParams(params,lease))}},getGui(){return methods.getGui.call(instance)},...methods.refresh===void 0?{}:{refresh(params){return methods.refresh.call(instance,scopeRendererParams(params,lease))}},...methods.focusIn===void 0?{}:{focusIn(){methods.focusIn.call(instance)}},...methods.focusOut===void 0?{}:{focusOut(){methods.focusOut.call(instance)}},destroy(){lease.active=false;return destroyUnderlyingRenderer(instance,methods.destroy,true)}}}function scopeEagerRendererDefinition(definition,claimedInstances){return{type:"factory",async create(context){const lease={active:true};const scopedParams=scopeRendererParams(context.params,lease);try{const candidate=definition.type==="class"?new definition.component:await definition.create({params:scopedParams,signal:context.signal});if(!isRendererWeakKey(candidate)){return candidate}if(claimedInstances.has(candidate)){throw invalidRendererInstance(context.params.instanceId)}claimedInstances.add(candidate);const instance=candidate;let capturedDestroy;let destroyWasRead=false;let methods;try{methods=captureRendererMethods(instance,destroy=>{destroyWasRead=true;capturedDestroy=destroy})}catch(cause){lease.active=false;try{await destroyUnderlyingRenderer(candidate,capturedDestroy,destroyWasRead)}catch(destroyCause){throw invalidRendererInstance(context.params.instanceId,new AggregateError([cause,destroyCause],"Renderer validation and cleanup both failed."))}throw invalidRendererInstance(context.params.instanceId,cause)}return createScopedRendererInstance(instance,lease,methods)}catch(cause){lease.active=false;throw cause}}}}function scopeRendererDefinition(definition,claimedInstances){if(definition.type!=="lazy"){return scopeEagerRendererDefinition(definition,claimedInstances)}return{type:"lazy",async load(context){return scopeEagerRendererDefinition(await definition.load(context),claimedInstances)}}}function projectPureRendererInput(params){return{value:params.value,row:params.row,rowIndex:params.rowIndex,colIndex:params.colIndex,colId:params.colId,formatted:params.formatted,meta:params.meta}}class PureRendererLifecycle{output;destroyed=false;renderer;constructor(renderer){this.renderer=renderer}init(params){this.output=this.renderer(projectPureRendererInput(params))}getGui(){if(!this.output||this.destroyed){throw new Error("Pure renderer GUI requested outside its mounted lifecycle.")}return this.output}refresh(params){if(this.destroyed)return false;this.output=this.renderer(projectPureRendererInput(params));return true}destroy(){if(this.destroyed)return;this.destroyed=true;this.output=void 0}}export function adaptPureCellRenderer(renderer){return{type:"factory",create:()=>new PureRendererLifecycle(renderer)}}export function normalizeGridRendererSource(source){return typeof source==="function"?adaptPureCellRenderer(source):source}export function createGridRendererAdapter(options={}){const runtime=createGridComponentRuntime({...options,kind:"renderer"});return{runtime,mount(request){return runtime.mount({key:request.key,componentName:request.componentName,definition:scopeRendererDefinition(normalizeGridRendererSource(request.source),CLAIMED_RENDERER_INSTANCES),params:request.params})},refresh(key,params){return runtime.refresh(key,params)}}}