@syidax/advanced 0.0.0-stage → 1.0.1

package/dist/collection/components/chart/_shared/core/data/transforms.js

@@ -0,0 +1 @@
+import{cellText,cellToNumber,datasetFromRows,isEmptyCell}from"./dataset.js";function comparable(value,dim){if(value===void 0)return null;return cellToNumber(value,dim.type==="ordinal"?"number":dim.type)}function sameCell(cell,expected){if(isEmptyCell(cell))return isEmptyCell(expected);if(isEmptyCell(expected))return false;if(typeof cell==="number"&&typeof expected==="string")return cell===Number(expected);if(typeof cell==="string"&&typeof expected==="number")return Number(cell)===expected;if(cell instanceof Date||expected instanceof Date)return cellToNumber(cell,"time")===cellToNumber(expected,"time");return cell===expected}export function matchesCondition(dataset,row,condition){if("and"in condition)return condition.and.every(entry=>matchesCondition(dataset,row,entry));if("or"in condition)return condition.or.some(entry=>matchesCondition(dataset,row,entry));if("not"in condition)return!matchesCondition(dataset,row,condition.not);const dim=dataset.dimension(condition.dimension);if(!dim)return false;const cell=row[dim.index];if(condition.empty!==void 0){if(isEmptyCell(cell)!==condition.empty)return false}if(isEmptyCell(cell)){if("eq"in condition)return isEmptyCell(condition.eq);return condition.empty===true&&!("ne"in condition||"gt"in condition||"gte"in condition||"lt"in condition||"lte"in condition||"in"in condition||"notIn"in condition||"contains"in condition||"startsWith"in condition||"regexp"in condition)}if("eq"in condition&&!sameCell(cell,condition.eq))return false;if("ne"in condition&&sameCell(cell,condition.ne))return false;if(condition.in&&!condition.in.some(candidate=>sameCell(cell,candidate)))return false;if(condition.notIn&&condition.notIn.some(candidate=>sameCell(cell,candidate)))return false;const numeric=dim.type==="ordinal"?cellToNumber(cell,"number"):cellToNumber(cell,dim.type);for(const key of["gt","gte","lt","lte"]){const bound=comparable(condition[key],dim);if(condition[key]===void 0)continue;if(bound===null||numeric===null)return false;if(key==="gt"&&!(numeric>bound))return false;if(key==="gte"&&!(numeric>=bound))return false;if(key==="lt"&&!(numeric<bound))return false;if(key==="lte"&&!(numeric<=bound))return false}const text=cellText(cell);if(condition.contains!==void 0&&!text.includes(condition.contains))return false;if(condition.startsWith!==void 0&&!text.startsWith(condition.startsWith))return false;if(condition.regexp!==void 0){const pattern=typeof condition.regexp==="string"?new RegExp(condition.regexp):condition.regexp;if(!pattern.test(text))return false}return true}export function filterDataset(dataset,condition,id){return datasetFromRows(dataset.dimensions,dataset.rows.filter(row=>matchesCondition(dataset,row,condition)),id)}export function sortDataset(dataset,keys,id){const list=Array.isArray(keys)?keys:[keys];const resolved=list.map(key=>({dim:dataset.dimension(key.dimension),direction:key.order==="desc"?-1:1})).filter(key=>key.dim!==void 0);if(resolved.length===0)return datasetFromRows(dataset.dimensions,dataset.rows,id);const indexed=dataset.rows.map((row,index)=>({row,index}));indexed.sort((a,b)=>{for(const{dim,direction}of resolved){const cellA=a.row[dim.index];const cellB=b.row[dim.index];const emptyA=isEmptyCell(cellA);const emptyB=isEmptyCell(cellB);if(emptyA||emptyB){if(emptyA&&emptyB)continue;return emptyA?1:-1}let cmp=0;if(dim.type==="ordinal"){const textA=cellText(cellA);const textB=cellText(cellB);cmp=textA<textB?-1:textA>textB?1:0}else{const numA=cellToNumber(cellA,dim.type)??Number.NaN;const numB=cellToNumber(cellB,dim.type)??Number.NaN;if(Number.isNaN(numA)||Number.isNaN(numB))cmp=Number.isNaN(numA)?Number.isNaN(numB)?0:1:-1;else cmp=numA<numB?-1:numA>numB?1:0}if(cmp!==0)return cmp*direction}return a.index-b.index});return datasetFromRows(dataset.dimensions,indexed.map(entry=>entry.row),id)}function xyPairs(dataset,dims){const xs=dataset.numbers(dims?.[0]??0);const ys=dataset.numbers(dims?.[1]??1);const pairs=[];for(let i=0;i<Math.min(xs.length,ys.length);i++){const x=xs[i];const y=ys[i];if(x!==null&&y!==null)pairs.push([x,y])}return pairs.sort((a,b)=>a[0]-b[0])}function rSquaredOf(pairs,predict){if(pairs.length===0)return 0;const mean=pairs.reduce((sum,[,y])=>sum+y,0)/pairs.length;let ssTot=0;let ssRes=0;for(const[x,y]of pairs){ssTot+=(y-mean)**2;ssRes+=(y-predict(x))**2}return ssTot===0?ssRes===0?1:0:Math.max(0,1-ssRes/ssTot)}function linearFit(pairs){const n=pairs.length;if(n===0)return[0,0];let sx=0;let sy=0;let sxx=0;let sxy=0;for(const[x,y]of pairs){sx+=x;sy+=y;sxx+=x*x;sxy+=x*y}const denominator=n*sxx-sx*sx;const slope=denominator===0?0:(n*sxy-sx*sy)/denominator;const intercept=(sy-slope*sx)/n;return[intercept,slope]}function polynomialFit(pairs,order){const k=Math.max(1,Math.floor(order));const size=k+1;const matrix=Array.from({length:size},()=>new Array(size+1).fill(0));for(const[x,y]of pairs){const powers=[1];for(let p=1;p<=2*k;p++)powers.push(powers[p-1]*x);for(let r=0;r<size;r++){for(let c=0;c<size;c++)matrix[r][c]+=powers[r+c];matrix[r][size]+=powers[r]*y}}for(let col=0;col<size;col++){let pivot=col;for(let r=col+1;r<size;r++)if(Math.abs(matrix[r][col])>Math.abs(matrix[pivot][col]))pivot=r;if(Math.abs(matrix[pivot][col])<1e-12)continue;[matrix[col],matrix[pivot]]=[matrix[pivot],matrix[col]];for(let r=0;r<size;r++){if(r===col)continue;const factor=matrix[r][col]/matrix[col][col];for(let c=col;c<=size;c++)matrix[r][c]-=factor*matrix[col][c]}}return matrix.map((row,r)=>Math.abs(row[r])<1e-12?0:row[size]/row[r])}const fmt=value=>{const rounded=Math.round(value*100)/100;return Number.isFinite(rounded)?String(rounded):"0"};export function regressionDataset(dataset,options={}){const method=options.method??"linear";const pairs=xyPairs(dataset,options.dimensions);let parameters=[];let predict=()=>0;let expression="";if(method==="linear"){const[intercept,slope]=linearFit(pairs);parameters=[intercept,slope];predict=x=>intercept+slope*x;expression=`y = ${fmt(slope)}x ${intercept<0?"-":"+"} ${fmt(Math.abs(intercept))}`}else if(method==="exponential"){const positive=pairs.filter(([,y])=>y>0);const[lnA,b]=linearFit(positive.map(([x,y])=>[x,Math.log(y)]));const a=Math.exp(lnA);parameters=[a,b];predict=x=>a*Math.exp(b*x);expression=`y = ${fmt(a)}e^(${fmt(b)}x)`}else if(method==="logarithmic"){const positive=pairs.filter(([x])=>x>0);const[a,b]=linearFit(positive.map(([x,y])=>[Math.log(x),y]));parameters=[a,b];predict=x=>x>0?a+b*Math.log(x):Number.NaN;expression=`y = ${fmt(a)} ${b<0?"-":"+"} ${fmt(Math.abs(b))}ln(x)`}else{const order=Math.max(1,Math.floor(options.order??2));parameters=polynomialFit(pairs,order);predict=x=>parameters.reduce((sum,coefficient,power)=>sum+coefficient*x**power,0);expression=`y = ${parameters.map((coefficient,power)=>power===0?fmt(coefficient):`${fmt(coefficient)}x${power>1?`^${power}`:""}`).reverse().join(" + ")}`}const points=pairs.map(([x])=>[x,predict(x)]).filter(([,y])=>Number.isFinite(y));const xDim=dataset.dimension(options.dimensions?.[0]??0);const yDim=dataset.dimension(options.dimensions?.[1]??1);const names=options.outputDimensions??[xDim?.name??"x",yDim?.name??"y"];const dims=[{name:names[0],type:xDim?.type==="time"?"time":"number"},{name:names[1],type:"number"}];return{method,parameters,rSquared:rSquaredOf(pairs.filter(([x])=>Number.isFinite(predict(x))),predict),expression,points,dataset:datasetFromRows(dims,points)}}function defaultValueDimension(dataset){const numbers=dataset.dimensions.filter(dim=>dim.type==="number");return numbers[numbers.length-1]??dataset.dimensions[dataset.dimensions.length-1]}export function quantileSorted(ascending,p){const n=ascending.length;if(n===0)return Number.NaN;if(n===1)return ascending[0];const position=(n-1)*Math.min(1,Math.max(0,p));const lower=Math.floor(position);const upper=Math.ceil(position);return ascending[lower]+(ascending[upper]-ascending[lower])*(position-lower)}export function summarizeBox(name,values,whisker=1.5){const ascending=values.filter(value=>Number.isFinite(value)).sort((a,b)=>a-b);if(ascending.length===0)return{name,min:Number.NaN,q1:Number.NaN,median:Number.NaN,q3:Number.NaN,max:Number.NaN,outliers:[],count:0};const q1=quantileSorted(ascending,.25);const median=quantileSorted(ascending,.5);const q3=quantileSorted(ascending,.75);const iqr=q3-q1;const low=q1-whisker*iqr;const high=q3+whisker*iqr;const inside=ascending.filter(value=>value>=low&&value<=high);const outliers=ascending.filter(value=>value<low||value>high);return{name,min:inside[0]??ascending[0],q1,median,q3,max:inside[inside.length-1]??ascending[ascending.length-1],outliers,count:ascending.length}}export function boxplotDataset(dataset,options={}){const valueDim=options.dimension!==void 0?dataset.dimension(options.dimension):defaultValueDimension(dataset);const groupDim=options.groupBy!==void 0?dataset.dimension(options.groupBy):void 0;const nameDimension=options.nameDimension??"name";const groups=new Map;if(valueDim){const values=dataset.numbers(valueDim.index);for(let i=0;i<dataset.rows.length;i++){const value=values[i];if(value===null)continue;const key=groupDim?cellText(dataset.rows[i][groupDim.index]):valueDim.displayName;let list=groups.get(key);if(!list){list=[];groups.set(key,list)}list.push(value)}}const summaries=[...groups.entries()].map(([name,values])=>summarizeBox(name,values,options.whisker));const boxDims=[{name:nameDimension,type:"ordinal"},{name:"min",type:"number"},{name:"q1",type:"number"},{name:"median",type:"number"},{name:"q3",type:"number"},{name:"max",type:"number"}];const outlierDims=[{name:nameDimension,type:"ordinal"},{name:"value",type:"number"}];return{summaries,dataset:datasetFromRows(boxDims,summaries.map(s=>[s.name,s.min,s.q1,s.median,s.q3,s.max])),outliers:datasetFromRows(outlierDims,summaries.flatMap(s=>s.outliers.map(value=>[s.name,value])))}}export function lttbIndices(xs,ys,target){const n=Math.min(xs.length,ys.length);const wanted=Math.floor(target);if(wanted>=n||n===0)return Array.from({length:n},(_,i)=>i);if(wanted<=2)return wanted<=1?[0]:[0,n-1];const kept=[0];const bucketSize=(n-2)/(wanted-2);let a=0;for(let i=0;i<wanted-2;i++){const rangeStart=Math.floor((i+1)*bucketSize)+1;const rangeEnd=Math.min(Math.floor((i+2)*bucketSize)+1,n);let avgX=0;let avgY=0;for(let j=rangeStart;j<rangeEnd;j++){avgX+=xs[j];avgY+=ys[j]}const span=Math.max(1,rangeEnd-rangeStart);avgX/=span;avgY/=span;const bucketStart=Math.floor(i*bucketSize)+1;const bucketEnd=Math.min(Math.floor((i+1)*bucketSize)+1,n);let best=bucketStart;let bestArea=-1;for(let j=bucketStart;j<bucketEnd;j++){const area=Math.abs((xs[a]-avgX)*(ys[j]-ys[a])-(xs[a]-xs[j])*(avgY-ys[a]));if(area>bestArea){bestArea=area;best=j}}kept.push(best);a=best}kept.push(n-1);return kept}export function sampleDataset(dataset,options={},id){const method=options.method??"lttb";const target=Math.max(1,Math.floor(options.target??100));const valueDim=options.dimension!==void 0?dataset.dimension(options.dimension):defaultValueDimension(dataset);const n=dataset.rows.length;if(!valueDim||n<=target)return datasetFromRows(dataset.dimensions,dataset.rows,id);const ys=dataset.numbers(valueDim.index).map(value=>value??Number.NaN);if(method==="lttb"){const firstNumber=dataset.dimensions.find(dim=>dim.type==="number");const xDim=options.xDimension!==void 0?dataset.dimension(options.xDimension):firstNumber&&firstNumber.index!==valueDim.index?firstNumber:void 0;const xs=xDim?dataset.numbers(xDim.index).map((value,i)=>value??i):ys.map((_,i)=>i);const finiteYs=ys.map((y,i)=>Number.isFinite(y)?y:i>0&&Number.isFinite(ys[i-1])?ys[i-1]:0);const kept=lttbIndices(xs,finiteYs,target);return datasetFromRows(dataset.dimensions,kept.map(i=>dataset.rows[i]),id)}const bucketSize=n/target;const rows=[];for(let b=0;b<target;b++){const start=Math.floor(b*bucketSize);const end=Math.min(n,Math.floor((b+1)*bucketSize));if(end<=start)continue;const values=ys.slice(start,end).filter(value=>Number.isFinite(value));let picked=start;let aggregate=values.length>0?values[0]:null;if(method==="average")aggregate=values.length>0?values.reduce((sum,value)=>sum+value,0)/values.length:null;else if(method==="sum")aggregate=values.length>0?values.reduce((sum,value)=>sum+value,0):null;else if(method==="max"||method==="min"){let bestIndex=-1;for(let i=start;i<end;i++){if(!Number.isFinite(ys[i]))continue;if(bestIndex<0||(method==="max"?ys[i]>ys[bestIndex]:ys[i]<ys[bestIndex]))bestIndex=i}picked=bestIndex<0?start:bestIndex;aggregate=bestIndex<0?null:ys[bestIndex]}else if(method==="last"){picked=end-1;aggregate=Number.isFinite(ys[end-1])?ys[end-1]:null}else{aggregate=Number.isFinite(ys[start])?ys[start]:null}const row=[...dataset.rows[picked]];row[valueDim.index]=aggregate;rows.push(row)}return datasetFromRows(dataset.dimensions,rows,id)}export function applyTransform(dataset,transform,id){switch(transform.type){case"filter":return filterDataset(dataset,transform.config,id);case"sort":return sortDataset(dataset,transform.config,id);case"regression":{const result=regressionDataset(dataset,transform.config);return id===void 0?result.dataset:datasetFromRows(result.dataset.dimensions,result.dataset.rows,id)}case"boxplot":{const result=boxplotDataset(dataset,transform.config);return id===void 0?result.dataset:datasetFromRows(result.dataset.dimensions,result.dataset.rows,id)}case"sample":return sampleDataset(dataset,transform.config,id);default:return dataset}}export function applyTransforms(dataset,transforms,id){return transforms.reduce((current,transform,index)=>applyTransform(current,transform,index===transforms.length-1?id:void 0),dataset)}

package/dist/collection/components/chart/_shared/core/data/values-attribute.js

@@ -0,0 +1 @@
+const SEPARATORS=/[,\s;]+/;function splitTokens(text){return text.trim().split(SEPARATORS).filter(token=>token.length>0)}function looksLikeJson(text){const trimmed=text.trim();return trimmed.startsWith("[")&&trimmed.endsWith("]")}function tryJson(text){if(!looksLikeJson(text))return null;try{const parsed=JSON.parse(text);return Array.isArray(parsed)?parsed:null}catch{return null}}export function parseNumberList(text){const tokens=splitTokens(text);const out=new Float32Array(tokens.length);for(let i=0;i<tokens.length;i+=1){const value=Number(tokens[i]);out[i]=tokens[i].length>0&&Number.isFinite(value)?value:Number.NaN}return out}export function parseValuesAttribute(text){const json=tryJson(text);if(json){if(json.every(item=>typeof item==="number"||item===null)){return Float32Array.from(json,item=>typeof item==="number"?item:Number.NaN)}return json}return parseNumberList(text)}export function parseCategoriesAttribute(text){const json=tryJson(text);if(json)return json.map(item=>String(item));return text.split(",").map(token=>token.trim()).filter(token=>token.length>0)}

package/dist/collection/components/chart/_shared/core/drawing/drawing-contract.js

@@ -0,0 +1 @@
+import{BUILT_IN_DRAWING_TOOLS,SEGMENT_TOOL}from"./drawing-tools.js";export const EMPTY_DRAWING_STATE=Object.freeze({drawings:[],seed:0});const DASHES=["solid","dashed","dotted"];function isPlainObject(value){return Boolean(value)&&typeof value==="object"&&!Array.isArray(value)}const toCoordinate=value=>{if(typeof value==="number")return Number.isFinite(value)?value:null;if(value instanceof Date||typeof value==="string"){const ms=new Date(value).getTime();return Number.isFinite(ms)?ms:null}return null};export function resolveDrawingAnchor(input){if(Array.isArray(input)){if(input.length<2)return null;const x2=toCoordinate(input[0]);const y2=typeof input[1]==="number"&&Number.isFinite(input[1])?input[1]:null;return x2===null||y2===null?null:{x:x2,y:y2}}if(!isPlainObject(input))return null;const x=toCoordinate(input.x);const y=typeof input.y==="number"&&Number.isFinite(input.y)?input.y:null;return x===null||y===null?null:{x,y}}export function resolveDrawingStyle(input){if(!isPlainObject(input))return void 0;const style={};if(typeof input.color==="string"&&input.color!=="")style.color=input.color;if(typeof input.width==="number"&&Number.isFinite(input.width)&&input.width>=0)style.width=input.width;if(DASHES.includes(input.dash))style.dash=input.dash;if(typeof input.opacity==="number"&&Number.isFinite(input.opacity))style.opacity=Math.min(1,Math.max(0,input.opacity));if(typeof input.fill==="string"&&input.fill!=="")style.fill=input.fill;if(typeof input.fillOpacity==="number"&&Number.isFinite(input.fillOpacity))style.fillOpacity=Math.min(1,Math.max(0,input.fillOpacity));if(typeof input.fontSize==="number"&&Number.isFinite(input.fontSize)&&input.fontSize>0)style.fontSize=input.fontSize;return Object.keys(style).length>0?style:void 0}export function resolveDrawing(input,id){if(!isPlainObject(input)||typeof input.tool!=="string"||input.tool==="")return null;if(!Array.isArray(input.anchors)||input.anchors.length===0)return null;const anchors=[];for(const raw of input.anchors){const anchor=resolveDrawingAnchor(raw);if(!anchor)return null;anchors.push(anchor)}const definition=drawingTool(input.tool);if(definition&&!acceptsAnchorCount(definition,anchors.length))return null;const style=resolveDrawingStyle(input.style);return{id,tool:input.tool,anchors,space:input.space==="pixel"?"pixel":"data",visible:input.visible!==false,...input.locked===true?{locked:true}:{},...style?{style}:{},...isPlainObject(input.options)?{options:{...input.options}}:{},...isPlainObject(input.meta)?{meta:{...input.meta}}:{}}}const mintId=seed=>`drawing-${seed}`;export function applyDrawingAction(state,action){switch(action.type){case"add":{const explicit=typeof action.drawing?.id==="string"&&action.drawing.id!=="";const seed=explicit?state.seed:state.seed+1;const id=explicit?action.drawing.id:mintId(seed);const drawing=resolveDrawing(action.drawing,id);if(!drawing)return state;const at=state.drawings.findIndex(d=>d.id===id);const drawings=at===-1?[...state.drawings,drawing]:state.drawings.map((d,i)=>i===at?drawing:d);return{seed,drawings}}case"update":{let changed=false;const drawings=state.drawings.map(drawing=>{if(drawing.id!==action.id)return drawing;const patched=resolveDrawing({...drawing,...action.patch,id:drawing.id},drawing.id);if(!patched)return drawing;changed=true;return patched});return changed?{...state,drawings}:state}case"move":{if(!Number.isFinite(action.dx)||!Number.isFinite(action.dy)||action.dx===0&&action.dy===0)return state;let changed=false;const drawings=state.drawings.map(drawing=>{if(drawing.id!==action.id||drawing.locked)return drawing;changed=true;return{...drawing,anchors:drawing.anchors.map(a=>({x:a.x+action.dx,y:a.y+action.dy}))}});return changed?{...state,drawings}:state}case"anchor":{const next=resolveDrawingAnchor(action.anchor);if(!next)return state;let changed=false;const drawings=state.drawings.map(drawing=>{if(drawing.id!==action.id||drawing.locked||action.index<0||action.index>=drawing.anchors.length)return drawing;changed=true;return{...drawing,anchors:drawing.anchors.map((a,i)=>i===action.index?next:a)}});return changed?{...state,drawings}:state}case"anchors":{const byId=new Map;for(const entry of Array.isArray(action.entries)?action.entries:[])if(entry&&typeof entry.id==="string")byId.set(entry.id,entry.anchors);if(byId.size===0)return state;let changed=false;const drawings=state.drawings.map(drawing=>{const anchors=byId.get(drawing.id);if(!anchors||drawing.locked)return drawing;const resolved=resolveDrawing({...drawing,anchors},drawing.id);if(!resolved)return drawing;changed=true;return resolved});return changed?{...state,drawings}:state}case"remove":{const drawings=state.drawings.filter(d=>d.id!==action.id);return drawings.length===state.drawings.length?state:{...state,drawings}}case"removeMany":{const ids=new Set(Array.isArray(action.ids)?action.ids:[]);if(ids.size===0)return state;const drawings=state.drawings.filter(d=>!ids.has(d.id)||d.locked===true);return drawings.length===state.drawings.length?state:{...state,drawings}}case"clear":return state.drawings.length===0?state:{...state,drawings:[]};case"set":{let seed=state.seed;const drawings=[];for(const input of Array.isArray(action.drawings)?action.drawings:[]){const explicit=typeof input?.id==="string"&&input.id!=="";const id=explicit?input.id:mintId(seed+=1);const drawing=resolveDrawing(input,id);if(drawing&&!drawings.some(d=>d.id===drawing.id))drawings.push(drawing)}return{seed,drawings}}default:return state}}export function findDrawing(state,id){return state.drawings.find(d=>d.id===id)}export const DRAWING_HISTORY_CAP=100;export function createDrawingHistory(present=EMPTY_DRAWING_STATE){return{past:[],present,future:[]}}export function historyApply(history,action){const next=applyDrawingAction(history.present,action);if(next===history.present)return history;const past=[...history.past,history.present];return{past:past.slice(Math.max(0,past.length-DRAWING_HISTORY_CAP)),present:next,future:[]}}export function historyUndo(history){if(history.past.length===0)return history;return{past:history.past.slice(0,-1),present:history.past[history.past.length-1],future:[history.present,...history.future]}}export function historyRedo(history){if(history.future.length===0)return history;return{past:[...history.past,history.present],present:history.future[0],future:history.future.slice(1)}}export const canUndo=history=>history.past.length>0;export const canRedo=history=>history.future.length>0;export const DRAWING_SCHEMA_VERSION=1;export function drawingsToDocument(state){return{v:DRAWING_SCHEMA_VERSION,seed:state.seed,drawings:state.drawings.map(d=>({...d,anchors:d.anchors.map(a=>({...a}))}))}}export function serializeDrawings(state){return JSON.stringify(drawingsToDocument(state))}export function deserializeDrawings(input){try{const parsed=typeof input==="string"?JSON.parse(input):input;if(!parsed||!Array.isArray(parsed.drawings))return EMPTY_DRAWING_STATE;const base=applyDrawingAction(EMPTY_DRAWING_STATE,{type:"set",drawings:parsed.drawings});return{...base,seed:Math.max(base.seed,typeof parsed.seed==="number"&&Number.isFinite(parsed.seed)?parsed.seed:0)}}catch{return EMPTY_DRAWING_STATE}}export function resolveDrawingsInput(input){if(input===void 0||input===null||input==="")return EMPTY_DRAWING_STATE;if(typeof input==="string"){try{return resolveDrawingsInput(JSON.parse(input))}catch{return EMPTY_DRAWING_STATE}}if(Array.isArray(input))return applyDrawingAction(EMPTY_DRAWING_STATE,{type:"set",drawings:input});return deserializeDrawings(input)}export const DEFAULT_DRAWING_TOOL="segment";export function resolveDrawingMode(mode,tool){const wanted=mode==="draw"||mode===true||mode==="true"?"draw":mode==="select"?"select":"none";const name=typeof tool==="string"&&tool!==""?tool:DEFAULT_DRAWING_TOOL;if(wanted==="draw"&&!hasDrawingTool(name))return{mode:"none",tool:name};return{mode:wanted,tool:name}}export function drawingsChangeDetail(history,action,source,id){return{drawings:[...history.present.drawings],action,source,...id!==void 0?{id}:{},canUndo:canUndo(history),canRedo:canRedo(history)}}export function sameDrawingSelection(a,b){return a.length===b.length&&a.every((id,index)=>id===b[index])}export function pruneDrawingSelection(selected,state){const kept=selected.filter(id=>state.drawings.some(d=>d.id===id));return kept.length===selected.length?selected:kept}export const DRAWING_STYLE_DEFAULTS=Object.freeze({color:"var(--sy-drawing-color, #2563eb)",width:1.5,dash:"solid",opacity:1,fill:"var(--sy-drawing-fill, #2563eb)",fillOpacity:.12,fontSize:12});export function resolveDrawingStyleWithDefaults(style,defaults=DRAWING_STYLE_DEFAULTS){return{...defaults,...style??{}}}const registry=new Map;export function registerDrawingTool(definition){if(!definition||typeof definition.tool!=="string"||definition.tool==="")throw new Error("a drawing tool needs a name");registry.set(definition.tool,definition);return definition}export function drawingTool(name){return registry.get(name)}export function hasDrawingTool(name){return registry.has(name)}export function drawingToolNames(){return[...registry.keys()]}export function acceptsAnchorCount(definition,count){if(typeof definition.anchors==="number")return count===definition.anchors;return count>=definition.anchors.min&&(definition.anchors.max===void 0||count<=definition.anchors.max)}export function placementAnchorCount(definition){if(definition.placement==="free"||definition.placement==="poly")return Number.POSITIVE_INFINITY;return definition.placement==="click"?1:2}for(const tool of BUILT_IN_DRAWING_TOOLS)registry.set(tool.tool,tool);export{SEGMENT_TOOL};

package/dist/collection/components/chart/_shared/core/drawing/drawing-cursor.js

@@ -0,0 +1 @@
+import{DEFAULT_HIT_TOLERANCE_PX,pickDrawing}from"./drawing-hit.js";export const DRAWING_HANDLE_HOVER_PX=8;export const HANDLE_MIN_GAP_PX=10;export function drawingHoverTarget(point,rendered,selection,tolerance=DEFAULT_HIT_TOLERANCE_PX,handleRadius=DRAWING_HANDLE_HOVER_PX){for(const entry of rendered){if(!selection.includes(entry.id)||entry.drawing.locked===true)continue;for(const p of entry.points){if(Math.hypot(p.x-point.x,p.y-point.y)<=handleRadius)return"handle"}}const hit=pickDrawing(point,rendered,tolerance);return hit&&hit.drawing.locked!==true?"body":null}export function drawingCursor(mode,hover,dragging){if(mode==="draw")return"crosshair";if(mode!=="select")return"";if(dragging)return hover==="handle"?"grabbing":"move";if(hover==="handle")return"grab";if(hover==="body")return"move";return""}export function thinHandleIndices(points,minGapPx=HANDLE_MIN_GAP_PX){if(points.length===0)return[];const out=[0];let last=points[0];for(let i=1;i<points.length-1;i+=1){const p=points[i];if(Math.hypot(p.x-last.x,p.y-last.y)>=minGapPx){out.push(i);last=p}}if(points.length>1)out.push(points.length-1);return out}

package/dist/collection/components/chart/_shared/core/drawing/drawing-export.js

@@ -0,0 +1 @@
+export{composeSvgLayers,positionSvgLayer,svgDocumentFrame}from"../export/chart-export.js";const CHROME_SELECTOR='[data-selection-id], [data-handle-id], [class*="__drawing-marquee"], [class*="__drawing--preview"]';export function snapshotDrawingLayer(svg,options={}){if(typeof document==="undefined"||!svg)return null;const clone=svg.cloneNode(true);for(const chrome of Array.from(clone.querySelectorAll(CHROME_SELECTOR)))chrome.remove();const count=clone.querySelectorAll("[data-drawing-id]").length;if(count===0)return null;clone.removeAttribute("style");clone.removeAttribute("aria-hidden");const width=Number(svg.getAttribute("width"))||svg.clientWidth||0;const height=Number(svg.getAttribute("height"))||svg.clientHeight||0;const left=Number.parseFloat(svg.style.left);const top=Number.parseFloat(svg.style.top);return{markup:new XMLSerializer().serializeToString(clone),x:options.plotX??(Number.isFinite(left)?left:0),y:options.plotY??(Number.isFinite(top)?top:0),width,height,count}}export function drawingsFileBaseName(base){const trimmed=(base||"").trim();return`${trimmed||"chart"}-drawings`}

package/dist/collection/components/chart/_shared/core/drawing/drawing-hit.js

@@ -0,0 +1 @@
+import{primitiveBounds}from"./drawing-projection.js";export const DEFAULT_HIT_TOLERANCE_PX=6;function distanceToSegment(p,a,b){const dx=b.x-a.x;const dy=b.y-a.y;const lengthSq=dx*dx+dy*dy;const t=lengthSq===0?0:Math.max(0,Math.min(1,((p.x-a.x)*dx+(p.y-a.y)*dy)/lengthSq));const x=a.x+t*dx;const y=a.y+t*dy;return Math.hypot(p.x-x,p.y-y)}function pointInPolygon(p,polygon){let inside=false;for(let i=0,j=polygon.length-1;i<polygon.length;j=i,i+=1){const a=polygon[i];const b=polygon[j];const crosses=a.y>p.y!==b.y>p.y&&p.x<(b.x-a.x)*(p.y-a.y)/(b.y-a.y)+a.x;if(crosses)inside=!inside}return inside}function inRect(p,rect,pad=0){return p.x>=rect.x-pad&&p.x<=rect.x+rect.width+pad&&p.y>=rect.y-pad&&p.y<=rect.y+rect.height+pad}export function textBox(primitive,fontSize=12){const width=typeof primitive.width==="number"&&primitive.width>0?primitive.width:Math.max(fontSize*.6,primitive.text.length*fontSize*.6);const x=primitive.anchor==="end"?primitive.x-width:primitive.anchor==="middle"?primitive.x-width/2:primitive.x;const y=primitive.baseline==="hanging"?primitive.y:primitive.baseline==="middle"?primitive.y-fontSize/2:primitive.y-fontSize;return{x,y,width,height:fontSize}}export function hitTestPrimitive(point,primitive,tolerance=DEFAULT_HIT_TOLERANCE_PX,fontSize=12){switch(primitive.kind){case"line":return distanceToSegment(point,{x:primitive.x1,y:primitive.y1},{x:primitive.x2,y:primitive.y2})<=tolerance;case"polyline":{const points=primitive.points;if(points.length===0)return false;if(points.length===1)return Math.hypot(point.x-points[0].x,point.y-points[0].y)<=tolerance;for(let i=1;i<points.length;i+=1)if(distanceToSegment(point,points[i-1],points[i])<=tolerance)return true;if(primitive.closed){if(distanceToSegment(point,points[points.length-1],points[0])<=tolerance)return true;return points.length>=3&&pointInPolygon(point,points)}return false}case"rect":return inRect(point,primitive,tolerance);case"circle":return Math.hypot(point.x-primitive.cx,point.y-primitive.cy)<=primitive.r+tolerance;case"text":return inRect(point,textBox(primitive,fontSize),tolerance/2);case"path":{const bounds=primitiveBounds([primitive]);return bounds!==null&&inRect(point,bounds,tolerance)}default:return false}}export function hitTestDrawing(point,rendered,tolerance=DEFAULT_HIT_TOLERANCE_PX){if(!rendered.drawing.visible)return false;return rendered.primitives.some(primitive=>hitTestPrimitive(point,primitive,tolerance,rendered.style.fontSize))}export function pickDrawing(point,rendered,tolerance=DEFAULT_HIT_TOLERANCE_PX){for(let i=rendered.length-1;i>=0;i-=1)if(hitTestDrawing(point,rendered[i],tolerance))return rendered[i];return null}function rectsIntersect(a,b){return a.x<=b.x+b.width&&a.x+a.width>=b.x&&a.y<=b.y+b.height&&a.y+a.height>=b.y}function segmentIntersectsRect(a,b,rect){const dx=b.x-a.x;const dy=b.y-a.y;let tMin=0;let tMax=1;const clip=(delta,low,high,origin)=>{if(delta===0)return origin>=low&&origin<=high;const t0=(low-origin)/delta;const t1=(high-origin)/delta;tMin=Math.max(tMin,Math.min(t0,t1));tMax=Math.min(tMax,Math.max(t0,t1));return true};if(!clip(dx,rect.x,rect.x+rect.width,a.x))return false;if(!clip(dy,rect.y,rect.y+rect.height,a.y))return false;return tMax>=tMin}export function primitiveIntersectsRect(primitive,rect){switch(primitive.kind){case"line":return segmentIntersectsRect({x:primitive.x1,y:primitive.y1},{x:primitive.x2,y:primitive.y2},rect);case"polyline":{const points=primitive.points;if(points.length===0)return false;if(points.length===1)return inRect(points[0],rect);for(let i=1;i<points.length;i+=1)if(segmentIntersectsRect(points[i-1],points[i],rect))return true;if(primitive.closed){if(segmentIntersectsRect(points[points.length-1],points[0],rect))return true;return points.length>=3&&pointInPolygon({x:rect.x+rect.width/2,y:rect.y+rect.height/2},points)}return false}default:{const bounds=primitiveBounds([primitive]);return bounds!==null&&rectsIntersect(rect,bounds)}}}export function drawingsInRect(rect,rendered){return rendered.filter(entry=>entry.drawing.visible&&entry.primitives.some(primitive=>primitiveIntersectsRect(primitive,rect)))}export function rectFromPoints(a,b){return{x:Math.min(a.x,b.x),y:Math.min(a.y,b.y),width:Math.abs(a.x-b.x),height:Math.abs(a.y-b.y)}}

package/dist/collection/components/chart/_shared/core/drawing/drawing-interaction.js

@@ -0,0 +1 @@
+import{drawingTool,placementAnchorCount,sameDrawingSelection}from"./drawing-contract.js";import{DEFAULT_HIT_TOLERANCE_PX,drawingsInRect,pickDrawing,rectFromPoints}from"./drawing-hit.js";import{anchorFromPixel,projectDrawingAnchor,translatedDrawingAnchors}from"./drawing-projection.js";export const DRAWING_HANDLE_HIT_PX=8;const DEFAULT_MIN_DRAG_PX=4;export const POLY_CLOSE_PX=8;export const POLY_MIN_VERTICES=3;export const FREE_HAND_STEP_PX=2;function acceptsVertex(last,next,stepPx){if(!last)return true;const dx=next.x-last.x;const dy=next.y-last.y;return dx*dx+dy*dy>=stepPx*stepPx}function insidePlot(point,frame){const{plot}=frame;return point.x>=plot.x&&point.x<=plot.x+plot.width&&point.y>=plot.y&&point.y<=plot.y+plot.height}function clampToPlot(point,frame){const{plot}=frame;return{x:Math.min(plot.x+plot.width,Math.max(plot.x,point.x)),y:Math.min(plot.y+plot.height,Math.max(plot.y,point.y))}}export class DrawingInteraction{host;placement=null;suppressClick=false;hovering=false;selecting=null;constructor(host){this.host=host}get isDragging(){return this.selecting?.drag!=null}get dragsHandle(){return this.selecting?.drag?.handle!=null}get isPending(){return this.placement!==null||this.selecting!==null}get armed(){const mode=this.host.mode();return mode.mode==="draw"&&mode.tool!==null&&drawingTool(mode.tool)!==void 0}pointerDown(input){if(this.placement?.poly){this.placement.origin={x:input.x,y:input.y};this.placement.moved=false;return true}if(this.placement||this.selecting)return true;if((input.button??0)!==0)return false;const mode=this.host.mode();if(mode.mode==="select")return this.selectPointerDown(input);if(mode.mode!=="draw"||mode.tool===null)return false;const definition=drawingTool(mode.tool);const frame=this.host.frame();if(!definition||!frame)return false;const point={x:input.x,y:input.y};if(!insidePlot(point,frame))return false;const space=this.host.space?.()??"data";const first=anchorFromPixel(point,frame,space);this.placement={pointerId:input.pointerId,tool:mode.tool,space,count:placementAnchorCount(definition),origin:point,first,moved:false,vertices:definition.placement==="free"?[point]:null,poly:definition.placement==="poly"?[point]:null,polyAwaitingFirstRelease:definition.placement==="poly",polyCursor:definition.placement==="poly"?point:null};this.hovering=false;this.host.standDown();this.host.preview(this.previewFor(point,frame));return true}pointerMove(input){if(this.selecting)return this.selectPointerMove(input);const placement=this.placement;if(!placement){this.hover(input);return false}if(placement.pointerId!==input.pointerId)return false;const frame=this.host.frame();if(!frame)return true;const point=clampToPlot({x:input.x,y:input.y},frame);if(!placement.moved&&this.isMeaningful(point,placement.origin))placement.moved=true;if(placement.vertices&&acceptsVertex(placement.vertices[placement.vertices.length-1],point,FREE_HAND_STEP_PX))placement.vertices.push(point);if(placement.poly)placement.polyCursor=point;this.host.preview(this.previewFor(point,frame));return true}polyPointerUp(placement,point,frame){const poly=placement.poly;if(placement.polyAwaitingFirstRelease){placement.polyAwaitingFirstRelease=false;return true}const near=(a,b)=>Math.hypot(a.x-b.x,a.y-b.y)<=POLY_CLOSE_PX;const closesOnFirst=poly.length>=POLY_MIN_VERTICES&&near(point,poly[0]);const finishesOnLast=poly.length>=POLY_MIN_VERTICES&&near(point,poly[poly.length-1]);if(closesOnFirst||finishesOnLast){this.finishPoly(frame);return true}if(!near(point,poly[poly.length-1]))poly.push(point);placement.polyCursor=point;this.host.preview(this.previewFor(point,frame));return true}finishPoly(frame){const placement=this.placement;if(!placement?.poly)return;const poly=placement.poly;this.placement=null;this.host.preview(null);if(poly.length>=POLY_MIN_VERTICES){this.suppressClick=true;this.host.commit({tool:placement.tool,space:placement.space,anchors:poly.map(vertex=>anchorFromPixel(vertex,frame,placement.space))})}}pointerUp(input){if(this.selecting)return this.selectPointerUp(input);const placement=this.placement;if(!placement||placement.pointerId!==input.pointerId)return false;if(placement.poly){const frame2=this.host.frame();if(!frame2)return true;return this.polyPointerUp(placement,clampToPlot({x:input.x,y:input.y},frame2),frame2)}this.placement=null;this.host.preview(null);const frame=this.host.frame();if(!frame)return true;const point=clampToPlot({x:input.x,y:input.y},frame);const meaningful=placement.moved||this.isMeaningful(point,placement.origin);if(placement.vertices){if(acceptsVertex(placement.vertices[placement.vertices.length-1],point,FREE_HAND_STEP_PX))placement.vertices.push(point);if(meaningful&&placement.vertices.length>=2){this.suppressClick=true;this.host.commit({tool:placement.tool,space:placement.space,anchors:placement.vertices.map(vertex=>anchorFromPixel(vertex,frame,placement.space))})}return true}if(placement.count===2&&meaningful){this.suppressClick=true;this.host.commit({tool:placement.tool,space:placement.space,anchors:[placement.first,anchorFromPixel(point,frame,placement.space)]})}else if(placement.count===1&&!meaningful){this.suppressClick=true;this.host.commit({tool:placement.tool,space:placement.space,anchors:[placement.first]})}else if(meaningful){this.suppressClick=true}return true}pointerCancel(){if(this.selecting){const wasDragging=this.selecting.drag!==null&&this.selecting.moved;this.selecting=null;this.host.marquee?.(null);if(wasDragging)this.host.dragPreview?.(null);return}if(!this.placement)return;this.placement=null;this.host.preview(null)}handleAt(point,rendered,selection){let best=null;for(const entry of rendered){if(!selection.includes(entry.id)||entry.drawing.locked)continue;entry.points.forEach((p,index)=>{const distance=Math.hypot(p.x-point.x,p.y-point.y);if(distance<=DRAWING_HANDLE_HIT_PX&&(!best||distance<best.distance))best={entry,index,distance}})}return best?{entry:best.entry,index:best.index}:null}selectPointerDown(input){const frame=this.host.frame();const point={x:input.x,y:input.y};if(!frame||!insidePlot(point,frame))return false;const rendered=this.host.rendered?.()??[];const shift=input.shiftKey===true;const current=[...this.host.selection?.()??[]];const handle=shift?null:this.handleAt(point,rendered,current);if(handle){this.selecting={pointerId:input.pointerId,origin:point,marquee:null,shift,moved:false,drag:{entries:[{drawing:handle.entry.drawing,anchors:handle.entry.drawing.anchors}],handle:{id:handle.entry.id,index:handle.index}}};this.host.standDown();return true}const hit=pickDrawing(point,rendered,this.host.hitTolerancePx?.()??DEFAULT_HIT_TOLERANCE_PX);if(hit){const next=shift?current.includes(hit.id)?current.filter(id=>id!==hit.id):[...current,hit.id]:current.includes(hit.id)?current:[hit.id];this.applySelection(next,"click");const movable=shift?[]:rendered.filter(entry=>next.includes(entry.id)&&!entry.drawing.locked);this.selecting={pointerId:input.pointerId,origin:point,marquee:null,shift,moved:false,drag:movable.length>0?{entries:movable.map(entry=>({drawing:entry.drawing,anchors:entry.drawing.anchors})),handle:null}:null}}else{this.selecting={pointerId:input.pointerId,origin:point,marquee:{x:point.x,y:point.y,width:0,height:0},shift,moved:false,drag:null}}this.host.standDown();return true}lockToAxis(point,origin){return Math.abs(point.x-origin.x)>=Math.abs(point.y-origin.y)?{x:point.x,y:origin.y}:{x:origin.x,y:point.y}}draggedAnchors(selecting,rawPoint,frame,lock=false){const point=lock?this.lockToAxis(rawPoint,selecting.origin):rawPoint;const drag=selecting.drag;if(drag.handle){const{drawing,anchors}=drag.entries[0];const next=anchorFromPixel(point,frame,drawing.space);return[{id:drawing.id,anchors:anchors.map((anchor,index)=>index===drag.handle.index?next:anchor)}]}const dx=point.x-selecting.origin.x;const dy=point.y-selecting.origin.y;return drag.entries.map(({drawing,anchors})=>({id:drawing.id,anchors:translatedDrawingAnchors({anchors,space:drawing.space},dx,dy,frame)}))}selectPointerMove(input){const selecting=this.selecting;if(!selecting||selecting.pointerId!==input.pointerId)return false;const frame=this.host.frame();if(!frame)return true;const point=clampToPlot({x:input.x,y:input.y},frame);if(!selecting.moved&&this.isMeaningful(point,selecting.origin))selecting.moved=true;if(selecting.marquee){selecting.marquee=rectFromPoints(selecting.origin,point);this.host.marquee?.(selecting.moved?selecting.marquee:null)}else if(selecting.drag&&selecting.moved){this.host.dragPreview?.(this.draggedAnchors(selecting,point,frame,input.shiftKey===true))}return true}selectPointerUp(input){const selecting=this.selecting;if(!selecting||selecting.pointerId!==input.pointerId)return false;this.selecting=null;const frame=this.host.frame();const point=frame?clampToPlot({x:input.x,y:input.y},frame):{x:input.x,y:input.y};const meaningful=selecting.moved||this.isMeaningful(point,selecting.origin);if(selecting.marquee){this.host.marquee?.(null);if(meaningful){this.suppressClick=true;const rect=rectFromPoints(selecting.origin,point);const covered=drawingsInRect(rect,this.host.rendered?.()??[]).map(entry=>entry.id);const current=[...this.host.selection?.()??[]];this.applySelection(selecting.shift?[...current,...covered.filter(id=>!current.includes(id))]:covered,"marquee")}else if(!selecting.shift){this.applySelection([],"clear")}}else if(meaningful){this.suppressClick=true;if(selecting.drag&&frame){this.host.dragPreview?.(null);this.host.commitAnchors?.(this.draggedAnchors(selecting,point,frame,input.shiftKey===true))}}return true}applySelection(next,source){const current=this.host.selection?.()??[];if(sameDrawingSelection(current,next))return;this.host.select?.(next,source)}hover(input){if(this.placement)return false;const mode=this.host.mode();const definition=mode.mode==="draw"&&mode.tool!==null?drawingTool(mode.tool):void 0;const frame=definition?.placement==="click"?this.host.frame():void 0;const point={x:input.x,y:input.y};if(!definition||!frame||!insidePlot(point,frame)){this.hoverEnd();return false}const space=this.host.space?.()??"data";this.hovering=true;this.host.preview({tool:definition.tool,space,anchors:[anchorFromPixel(point,frame,space)],points:[point]});return true}hoverEnd(){if(!this.hovering)return;this.hovering=false;if(!this.placement)this.host.preview(null)}keyDown(input){const mode=this.host.mode().mode;if(input.key==="Escape"){if(this.placement||this.selecting){this.pointerCancel();return true}if(mode==="select"&&(this.host.selection?.()??[]).length>0){this.applySelection([],"keyboard");return true}return false}if(input.key==="Enter"&&this.placement?.poly){const frame=this.host.frame();if(frame)this.finishPoly(frame);else this.pointerCancel();return true}if(mode!=="draw"&&mode!=="select")return false;if(this.placement||this.selecting)return false;const primary=input.ctrlKey===true||input.metaKey===true;if((input.key==="Delete"||input.key==="Backspace")&&!primary&&mode==="select"){const selected=[...this.host.selection?.()??[]];if(selected.length===0||!this.host.remove)return false;this.host.remove(selected);return true}if(primary&&!input.altKey){const key=input.key.length===1?input.key.toLowerCase():input.key;if(key==="z"&&!input.shiftKey&&this.host.undo){this.host.undo();return true}if((key==="y"||key==="z"&&input.shiftKey===true)&&this.host.redo){this.host.redo();return true}}return false}consumeSuppressedClick(){const suppressed=this.suppressClick;this.suppressClick=false;return suppressed}dispose(){this.placement=null;this.selecting=null;this.suppressClick=false;this.hovering=false}isMeaningful(point,origin){const min=this.host.minDragPx?.()??DEFAULT_MIN_DRAG_PX;return Math.abs(point.x-origin.x)>=min||Math.abs(point.y-origin.y)>=min}previewFor(point,frame){const placement=this.placement;if(placement.poly){const last=placement.poly[placement.poly.length-1];const points=last.x===point.x&&last.y===point.y?[...placement.poly]:[...placement.poly,point];return{tool:placement.tool,space:placement.space,anchors:points.map(vertex=>anchorFromPixel(vertex,frame,placement.space)),points}}if(placement.vertices){const points=placement.vertices[placement.vertices.length-1]===point?[...placement.vertices]:[...placement.vertices,point];return{tool:placement.tool,space:placement.space,anchors:points.map(vertex=>anchorFromPixel(vertex,frame,placement.space)),points}}const firstPoint=projectDrawingAnchor(placement.first,frame,placement.space);if(placement.count===1)return{tool:placement.tool,space:placement.space,anchors:[placement.first],points:[firstPoint]};const second=anchorFromPixel(point,frame,placement.space);return{tool:placement.tool,space:placement.space,anchors:[placement.first,second],points:[firstPoint,point]}}}

package/dist/collection/components/chart/_shared/core/drawing/drawing-measure.js

@@ -0,0 +1 @@
+export const DRAWING_TEXT_FONT_FAMILY="system-ui, sans-serif";const fontGenerations=new WeakMap;function fontGeneration(doc){const fonts=doc?.fonts;if(!fonts)return 0;let generation=fontGenerations.get(fonts);if(!generation){generation={value:0};fontGenerations.set(fonts,generation);const current=generation;const changed=()=>{current.value++};fonts.addEventListener?.("loadingdone",changed);fonts.addEventListener?.("loadingerror",changed)}return generation.value}function measurementCache(doc){const cache=new Map;let generation=-1;let size=-1;return{clear:()=>cache.clear(),get(key){const next=fontGeneration(doc),nextSize=doc?.fonts?.size??0;if(next!==generation||nextSize!==size||doc?.fonts?.status==="loading")cache.clear();generation=next;size=nextSize;return cache.get(key)},set(key,value){if(doc?.fonts?.status==="loading")return;if(cache.size>2e3)cache.clear();cache.set(key,value)}}}export const estimateTextSize=(text,fontSize)=>({width:Math.max(fontSize*.6,text.length*fontSize*.6),height:fontSize});export function createCanvasTextMeasurer(family=DRAWING_TEXT_FONT_FAMILY,doc=typeof document!=="undefined"?document:void 0){let context;const cache=measurementCache(doc);const measure=(text,fontSize)=>{if(context===void 0){try{context=doc?.createElement("canvas").getContext("2d")??null}catch{context=null}}if(!context)return estimateTextSize(text,fontSize);const key=`${fontSize}|${text}`;let width=cache.get(key);if(width===void 0){context.font=`${fontSize}px ${family}`;width=context.measureText(text).width;cache.set(key,width)}return{width,height:fontSize}};return Object.assign(measure,{clear:cache.clear,dispose:()=>{cache.clear();context=void 0}})}const SVG_NS="http://www.w3.org/2000/svg";export function createSvgTextMeasurer(family=DRAWING_TEXT_FONT_FAMILY,doc=typeof document!=="undefined"?document:void 0,isActive=()=>true){const fallback=createCanvasTextMeasurer(family,doc);if(!doc||typeof doc.createElementNS!=="function")return fallback;const cache=measurementCache(doc);let text=null;let root=null;const ensure=()=>{if(text&&text.isConnected)return text;const svg=doc.createElementNS(SVG_NS,"svg");svg.setAttribute("aria-hidden","true");svg.setAttribute("data-sy-chart-text-measurer","");svg.setAttribute("style","position:absolute;left:-9999px;top:-9999px;width:0;height:0;overflow:hidden;visibility:hidden;pointer-events:none");const node=doc.createElementNS(SVG_NS,"text");svg.appendChild(node);const parent=doc.body??doc.documentElement;if(!parent)return null;parent.appendChild(svg);root=svg;text=node;return node};const measure=(value,fontSize)=>{if(!isActive())return estimateTextSize(value,fontSize);const key=`${fontSize}|${value}`;const cached=cache.get(key);if(cached!==void 0)return{width:cached,height:fontSize};const node=ensure();if(!node||typeof node.getComputedTextLength!=="function")return fallback(value,fontSize);node.setAttribute("style",`font-size:${fontSize}px;font-family:${family}`);node.textContent=value;const width=node.getComputedTextLength();if(!Number.isFinite(width)||width<0)return fallback(value,fontSize);cache.set(key,width);return{width,height:fontSize}};return Object.assign(measure,{clear:()=>{cache.clear();fallback.clear()},dispose:()=>{cache.clear();fallback.dispose();root?.remove();root=null;text=null}})}

package/dist/collection/components/chart/_shared/core/drawing/drawing-projection.js

@@ -0,0 +1 @@
+import{compositeOver,fallbackHex,parseCssColor,readableTextColor,toHex}from"../a11y/contrast.js";import{drawingTool,resolveDrawingStyleWithDefaults}from"./drawing-contract.js";export function projectDrawingAnchor(anchor,frame,space){if(space==="pixel")return{x:frame.plot.x+anchor.x,y:frame.plot.y+anchor.y};return{x:frame.xScale(anchor.x),y:frame.yScale(anchor.y)}}export function anchorFromPixel(point,frame,space){if(space==="pixel")return{x:point.x-frame.plot.x,y:point.y-frame.plot.y};return{x:frame.xScale.invert(point.x),y:frame.yScale.invert(point.y)}}export function projectDrawingAnchors(drawing,frame){return drawing.anchors.map(anchor=>projectDrawingAnchor(anchor,frame,drawing.space))}export function translatedDrawingAnchors(drawing,dx,dy,frame){return drawing.anchors.map(anchor=>{const point=projectDrawingAnchor(anchor,frame,drawing.space);return anchorFromPixel({x:point.x+dx,y:point.y+dy},frame,drawing.space)})}export function convertDrawingSpace(drawing,frame,space){if(drawing.space===space)return drawing.anchors.map(anchor=>({...anchor}));return drawing.anchors.map(anchor=>anchorFromPixel(projectDrawingAnchor(anchor,frame,drawing.space),frame,space))}export const DRAWING_LABEL_CONTRAST=5;export function tintedBackground(fill,fillOpacity,background){const resolve=s=>parseCssColor(s)??(fallbackHex(s)?parseCssColor(fallbackHex(s)):null);const bg=resolve(background);const tint=resolve(fill);if(!bg||!tint)return background;const solid=compositeOver(bg,{r:255,g:255,b:255,a:1});return toHex(compositeOver({...tint,a:(tint.a??1)*fillOpacity},solid))}export function renderDrawing(drawing,frame,extras){const definition=drawingTool(drawing.tool);const points=projectDrawingAnchors(drawing,frame);const style=resolveDrawingStyleWithDefaults(drawing.style);const primitives=definition?definition.render({drawing,points,plot:frame.plot,style,...extras?.measureText?{measureText:extras.measureText}:{}}):[];const background=extras?.background??"#ffffff";const filled=style.fillOpacity>0&&primitives.some(p=>p.kind==="rect"||p.kind==="circle"||p.kind==="polyline"&&p.closed===true);const labelColor=readableTextColor(style.color,filled?tintedBackground(style.fill,style.fillOpacity,background):background,DRAWING_LABEL_CONTRAST);return{id:drawing.id,tool:drawing.tool,drawing,points,style,primitives,unknownTool:!definition,labelColor}}export function renderDrawings(state,frame,extras){return state.drawings.filter(d=>d.visible).map(d=>renderDrawing(d,frame,extras))}export function primitiveBounds(primitives){let minX=Number.POSITIVE_INFINITY;let minY=Number.POSITIVE_INFINITY;let maxX=Number.NEGATIVE_INFINITY;let maxY=Number.NEGATIVE_INFINITY;const take=(x,y)=>{if(!Number.isFinite(x)||!Number.isFinite(y))return;minX=Math.min(minX,x);minY=Math.min(minY,y);maxX=Math.max(maxX,x);maxY=Math.max(maxY,y)};for(const p of primitives){switch(p.kind){case"line":take(p.x1,p.y1);take(p.x2,p.y2);break;case"polyline":for(const point of p.points)take(point.x,point.y);break;case"rect":take(p.x,p.y);take(p.x+p.width,p.y+p.height);break;case"circle":take(p.cx-p.r,p.cy-p.r);take(p.cx+p.r,p.cy+p.r);break;case"text":{const size=typeof p.height==="number"&&p.height>0?p.height:12;const width=typeof p.width==="number"&&p.width>0?p.width:Math.max(size*.6,p.text.length*size*.6);const left=p.anchor==="end"?p.x-width:p.anchor==="middle"?p.x-width/2:p.x;const top=p.baseline==="hanging"?p.y:p.baseline==="middle"?p.y-size/2:p.y-size;take(left,top);take(left+width,top+size);break}default:break}}if(!Number.isFinite(minX)||!Number.isFinite(minY))return null;return{x:minX,y:minY,width:maxX-minX,height:maxY-minY}}export function dashArrayFor(dash,width){if(dash==="dashed")return`${Math.max(2,width*4)} ${Math.max(2,width*2)}`;if(dash==="dotted")return`${Math.max(1,width)} ${Math.max(2,width*2)}`;return void 0}

package/dist/collection/components/chart/_shared/core/drawing/drawing-tools.js

@@ -0,0 +1 @@
+import{estimateTextSize}from"./drawing-measure.js";export function extendLineToPlot(p0,p1,plot,mode){const dx=p1.x-p0.x;const dy=p1.y-p0.y;if(dx===0&&dy===0)return null;if(mode==="none")return{x1:p0.x,y1:p0.y,x2:p1.x,y2:p1.y};let tMin=Number.NEGATIVE_INFINITY;let tMax=Number.POSITIVE_INFINITY;const clip=(delta,low,high,origin)=>{if(delta===0)return origin>=low&&origin<=high;const t0=(low-origin)/delta;const t1=(high-origin)/delta;tMin=Math.max(tMin,Math.min(t0,t1));tMax=Math.min(tMax,Math.max(t0,t1));return true};if(!clip(dx,plot.x,plot.x+plot.width,p0.x))return null;if(!clip(dy,plot.y,plot.y+plot.height,p0.y))return null;if(!Number.isFinite(tMin)||!Number.isFinite(tMax)||tMax<tMin)return null;const start=mode==="both"?tMin:0;const end=tMax;if(end<=start)return null;return{x1:p0.x+start*dx,y1:p0.y+start*dy,x2:p0.x+end*dx,y2:p0.y+end*dy}}export function resolveLineExtension(value,fallback="none"){return value==="ray"||value==="both"||value==="none"?value:fallback}const linePrimitives=(context,mode,role)=>{const{points,plot}=context;if(points.length<2)return[];const line=extendLineToPlot(points[0],points[1],plot,mode);return line?[{kind:"line",...line,role}]:[]};export const SEGMENT_TOOL={tool:"segment",anchors:2,placement:"drag",render:context=>linePrimitives(context,"none","segment")};export const TREND_LINE_TOOL={tool:"trend-line",anchors:2,placement:"drag",render:context=>{const mode=resolveLineExtension(context.drawing.options?.extend);return linePrimitives(context,mode,mode==="none"?"trend-line":mode==="ray"?"ray":"extended-line")}};export const RAY_TOOL={tool:"ray",anchors:2,placement:"drag",render:context=>linePrimitives(context,"ray","ray")};export const EXTENDED_LINE_TOOL={tool:"extended-line",anchors:2,placement:"drag",render:context=>linePrimitives(context,"both","extended-line")};export function formatDrawingValue(value){if(!Number.isFinite(value))return"";if(Number.isInteger(value))return String(value);return String(Math.round(value*100)/100)}export function levelLabel(context,axis){const options=context.drawing.options??{};const anchor=context.drawing.anchors[0];const parts=[];if(typeof options.label==="string"&&options.label!=="")parts.push(options.label);if(options.showValue===true&&anchor)parts.push(formatDrawingValue(anchor[axis]));return parts.filter(part=>part!=="").join(" · ")}const LABEL_PAD=4;const LABEL_HEIGHT=12;const horizontalLabel=(context,xEnd,y)=>{const text=levelLabel(context,"y");if(text==="")return[];const above=y-LABEL_PAD>=context.plot.y+LABEL_HEIGHT;return[{kind:"text",x:xEnd-LABEL_PAD,y:above?y-LABEL_PAD:y+LABEL_PAD+LABEL_HEIGHT,text,anchor:"end",baseline:"auto",role:"label"}]};const verticalLabel=(context,x)=>{const text=levelLabel(context,"x");if(text==="")return[];const right=x+LABEL_PAD+text.length*7<=context.plot.x+context.plot.width;return[{kind:"text",x:right?x+LABEL_PAD:x-LABEL_PAD,y:context.plot.y+LABEL_PAD,text,anchor:right?"start":"end",baseline:"hanging",role:"label"}]};const insideY=(y,plot)=>y>=plot.y&&y<=plot.y+plot.height;const insideX=(x,plot)=>x>=plot.x&&x<=plot.x+plot.width;export const HORIZONTAL_LINE_TOOL={tool:"horizontal-line",anchors:1,placement:"click",render:context=>{const{points,plot}=context;if(points.length<1||!insideY(points[0].y,plot))return[];const y=points[0].y;return[{kind:"line",x1:plot.x,y1:y,x2:plot.x+plot.width,y2:y,role:"horizontal-line"},...horizontalLabel(context,plot.x+plot.width,y)]}};export const HORIZONTAL_RAY_TOOL={tool:"horizontal-ray",anchors:1,placement:"click",render:context=>{const{points,plot}=context;if(points.length<1||!insideY(points[0].y,plot))return[];const{x,y}=points[0];const right=plot.x+plot.width;if(x>=right)return[];return[{kind:"line",x1:Math.max(plot.x,x),y1:y,x2:right,y2:y,role:"horizontal-ray"},...horizontalLabel(context,right,y)]}};export const VERTICAL_LINE_TOOL={tool:"vertical-line",anchors:1,placement:"click",render:context=>{const{points,plot}=context;if(points.length<1||!insideX(points[0].x,plot))return[];const x=points[0].x;return[{kind:"line",x1:x,y1:plot.y,x2:x,y2:plot.y+plot.height,role:"vertical-line"},...verticalLabel(context,x)]}};export const CROSS_LINE_TOOL={tool:"cross-line",anchors:1,placement:"click",render:context=>{const{points,plot}=context;if(points.length<1)return[];const{x,y}=points[0];const primitives=[];if(insideY(y,plot))primitives.push({kind:"line",x1:plot.x,y1:y,x2:plot.x+plot.width,y2:y,role:"cross-line-h"});if(insideX(x,plot))primitives.push({kind:"line",x1:x,y1:plot.y,x2:x,y2:plot.y+plot.height,role:"cross-line-v"});const text=levelLabel(context,"y");if(primitives.length>0&&text!=="")primitives.push({kind:"text",x:x+LABEL_PAD,y:y-LABEL_PAD,text,anchor:"start",baseline:"auto",role:"label"});return primitives}};export function rectangleFromCorners(a,b){const x=Math.min(a.x,b.x);const y=Math.min(a.y,b.y);const width=Math.abs(a.x-b.x);const height=Math.abs(a.y-b.y);if(width===0||height===0)return null;return{x,y,width,height}}export const RECTANGLE_TOOL={tool:"rectangle",anchors:2,placement:"drag",render:context=>{const{points,plot,drawing}=context;if(points.length<2)return[];const box=rectangleFromCorners(points[0],points[1]);if(!box)return[];if(box.x+box.width<plot.x||box.x>plot.x+plot.width||box.y+box.height<plot.y||box.y>plot.y+plot.height)return[];const primitives=[{kind:"rect",...box,role:"rectangle"}];const label=typeof drawing.options?.label==="string"?drawing.options.label:"";if(label!==""){primitives.push({kind:"text",x:Math.max(box.x,plot.x)+LABEL_PAD,y:Math.max(box.y,plot.y)+LABEL_PAD,text:label,anchor:"start",baseline:"hanging",role:"label"})}return primitives}};export const FIB_RETRACEMENT_LEVELS=Object.freeze([0,.236,.382,.5,.618,.786,1]);export function resolveFibLevels(value,fallback=FIB_RETRACEMENT_LEVELS){const raw=Array.isArray(value)?value:typeof value==="string"?value.split(","):null;if(!raw)return[...fallback];const levels=raw.map(entry=>typeof entry==="number"?entry:Number(String(entry).trim())).filter(level=>Number.isFinite(level));const unique=[...new Set(levels)].sort((a,b)=>a-b);return unique.length>0?unique:[...fallback]}export function resolveFibExtend(value){return value==="left"||value==="right"||value==="both"?value:"none"}export function fibLevelLabel(level,value,showValues){const ratio=String(Math.round(level*1e3)/1e3);return showValues?`${ratio} · ${formatDrawingValue(value)}`:ratio}export const FIB_RETRACEMENT_TOOL={tool:"fib-retracement",anchors:2,placement:"drag",render:context=>{const{points,plot,drawing}=context;if(points.length<2)return[];const[p0,p1]=points;if(p0.y===p1.y)return[];const options=drawing.options??{};const levels=resolveFibLevels(options.levels);const extend=resolveFibExtend(options.extend);const showValues=options.showValues!==false;const left=extend==="left"||extend==="both"?plot.x:Math.min(p0.x,p1.x);const right=extend==="right"||extend==="both"?plot.x+plot.width:Math.max(p0.x,p1.x);if(right<=left)return[];const anchorY0=drawing.anchors[0]?.y??0;const anchorY1=drawing.anchors[1]?.y??0;const yFor=level=>p0.y+level*(p1.y-p0.y);const valueFor=level=>anchorY0+level*(anchorY1-anchorY0);const primitives=[];for(let i=1;i<levels.length;i+=1){const top=yFor(levels[i-1]);const bottom=yFor(levels[i]);primitives.push({kind:"polyline",closed:true,points:[{x:left,y:top},{x:right,y:top},{x:right,y:bottom},{x:left,y:bottom}],role:"fib-band"})}const measure=context.measureText??estimateTextSize;let lastLabelY;for(const level of levels){const y=yFor(level);primitives.push({kind:"line",x1:left,y1:y,x2:right,y2:y,role:"fib-level"});if(lastLabelY!==void 0&&Math.abs(y-lastLabelY)<FIB_LABEL_MIN_GAP_PX)continue;lastLabelY=y;const text=fibLevelLabel(level,valueFor(level),showValues);const size=measure(text,context.style.fontSize);primitives.push({kind:"text",x:left+LABEL_PAD,y:y-LABEL_PAD,text,anchor:"start",baseline:"auto",role:"label",width:size.width,height:size.height})}return primitives}};export const FREE_HAND_TOOL={tool:"free-hand",anchors:{min:2},placement:"free",render:({points})=>points.length<2?[]:[{kind:"polyline",points:[...points],role:"free-hand"}]};export const DEFAULT_TEXT_ANNOTATION="Text";export const TEXT_ANNOTATION_PADDING=4;export const TEXT_LINE_HEIGHT=1.25;const resolveAlign=value=>value==="middle"||value==="end"?value:"start";const resolveValign=value=>value==="middle"||value==="bottom"?value:"top";export function layoutTextAnnotation(context){const{points,drawing,style}=context;if(points.length<1)return null;const options=drawing.options??{};const raw=typeof options.text==="string"?options.text:DEFAULT_TEXT_ANNOTATION;const lines=raw.split("\n");const measure=context.measureText??estimateTextSize;const fontSize=style.fontSize;const lineHeight=fontSize*TEXT_LINE_HEIGHT;const padding=typeof options.padding==="number"&&Number.isFinite(options.padding)&&options.padding>=0?options.padding:TEXT_ANNOTATION_PADDING;const width=Math.max(...lines.map(line=>measure(line,fontSize).width))+padding*2;const height=lines.length*lineHeight+padding*2;const align=resolveAlign(options.align);const valign=resolveValign(options.valign);const offset=options.offset&&typeof options.offset==="object"?options.offset:{};const ox=typeof offset.x==="number"&&Number.isFinite(offset.x)?offset.x:0;const oy=typeof offset.y==="number"&&Number.isFinite(offset.y)?offset.y:0;const ax=points[0].x+ox;const ay=points[0].y+oy;let x=align==="start"?ax:align==="middle"?ax-width/2:ax-width;let y=valign==="top"?ay:valign==="middle"?ay-height/2:ay-height;if(options.clamp!==false){const{plot}=context;if(width<=plot.width)x=Math.max(plot.x,Math.min(x,plot.x+plot.width-width));if(height<=plot.height)y=Math.max(plot.y,Math.min(y,plot.y+plot.height-height))}return{box:{x,y,width,height},lines,lineHeight,padding,align}}export const FIB_LABEL_MIN_GAP_PX=12;export const TEXT_TOOL={tool:"text",anchors:1,placement:"click",render:context=>{const layout=layoutTextAnnotation(context);if(!layout)return[];const{box,lines,lineHeight,padding,align}=layout;const options=context.drawing.options??{};const background=options.background;const boxStyle=background===false?{fillOpacity:0,width:0}:{fill:typeof background==="string"&&background!==""?background:"var(--sy-drawing-annotation-bg, #ffffff)",fillOpacity:.92,width:1,dash:"solid"};const primitives=[{kind:"rect",...box,role:"text-box",style:boxStyle}];const textX=align==="start"?box.x+padding:align==="middle"?box.x+box.width/2:box.x+box.width-padding;lines.forEach((line,index)=>{primitives.push({kind:"text",x:textX,y:box.y+padding+index*lineHeight,text:line,anchor:align,baseline:"hanging",role:"text"})});return primitives}};export const ARROW_HEAD_SIZE=10;export const ARROW_HEAD_WIDTH_RATIO=.6;export const resolveArrowHead=value=>value==="start"||value==="both"?value:"end";export const resolveArrowLabelAt=value=>value==="start"||value==="end"?value:"middle";export function arrowHeadGeometry(from,tip,size=ARROW_HEAD_SIZE){const dx=tip.x-from.x;const dy=tip.y-from.y;const length=Math.hypot(dx,dy);if(length===0)return null;const ux=dx/length;const uy=dy/length;const base={x:tip.x-ux*size,y:tip.y-uy*size};const half=size*ARROW_HEAD_WIDTH_RATIO/2;return{tip,base,corners:[{x:base.x-uy*half,y:base.y+ux*half},{x:base.x+uy*half,y:base.y-ux*half}]}}export const ARROW_TOOL={tool:"arrow",anchors:2,placement:"drag",render:context=>{const{points,drawing,style}=context;if(points.length<2)return[];const[p0,p1]=points;if(p0.x===p1.x&&p0.y===p1.y)return[];const options=drawing.options??{};const head=resolveArrowHead(options.head);const size=typeof options.headSize==="number"&&Number.isFinite(options.headSize)&&options.headSize>=2?options.headSize:ARROW_HEAD_SIZE;const headStyle={fill:style.color,fillOpacity:1,width:1,dash:"solid"};const primitives=[];let shaftStart=p0;let shaftEnd=p1;if(head==="end"||head==="both"){const geometry=arrowHeadGeometry(p0,p1,size);if(geometry){shaftEnd=geometry.base;primitives.push({kind:"polyline",closed:true,points:[geometry.tip,geometry.corners[0],geometry.corners[1]],role:"arrow-head",style:headStyle})}}if(head==="start"||head==="both"){const geometry=arrowHeadGeometry(p1,p0,size);if(geometry){shaftStart=geometry.base;primitives.push({kind:"polyline",closed:true,points:[geometry.tip,geometry.corners[0],geometry.corners[1]],role:"arrow-head",style:headStyle})}}primitives.unshift({kind:"line",x1:shaftStart.x,y1:shaftStart.y,x2:shaftEnd.x,y2:shaftEnd.y,role:"arrow-shaft"});const label=typeof options.label==="string"?options.label:"";if(label!==""){const at=resolveArrowLabelAt(options.labelAt);const anchor=at==="start"?p0:at==="end"?p1:{x:(p0.x+p1.x)/2,y:(p0.y+p1.y)/2};const length=Math.hypot(p1.x-p0.x,p1.y-p0.y);let nx=0;let ny=-1;if(length>1e-6){nx=-(p1.y-p0.y)/length;ny=(p1.x-p0.x)/length;if(ny>0){nx=-nx;ny=-ny}}const labelOptions={text:label,align:"middle",valign:"bottom",offset:{x:nx*6,y:ny*6},background:options.labelBackground??true,clamp:options.clamp!==false};primitives.push(...TEXT_TOOL.render({...context,points:[anchor],drawing:{...drawing,options:labelOptions}}))}return primitives}};export const ELLIPSE_SEGMENTS=64;export function ellipseOutline(cx,cy,rx,ry,segments=ELLIPSE_SEGMENTS){const points=[];for(let i=0;i<segments;i+=1){const t=i/segments*Math.PI*2;points.push({x:cx+Math.cos(t)*rx,y:cy+Math.sin(t)*ry})}return points}export function polygonContains(points,p){let inside=false;for(let i=0,j=points.length-1;i<points.length;j=i,i+=1){const a=points[i];const b=points[j];if(a.y>p.y!==b.y>p.y&&p.x<(b.x-a.x)*(p.y-a.y)/(b.y-a.y)+a.x)inside=!inside}return inside}export function polygonCentroid(points){if(points.length===0)return null;const average=points.reduce((acc,p)=>({x:acc.x+p.x,y:acc.y+p.y}),{x:0,y:0});const mean={x:average.x/points.length,y:average.y/points.length};if(points.length<3)return mean;let area2=0;let cx=0;let cy=0;for(let i=0,j=points.length-1;i<points.length;j=i,i+=1){const cross=points[j].x*points[i].y-points[i].x*points[j].y;area2+=cross;cx+=(points[j].x+points[i].x)*cross;cy+=(points[j].y+points[i].y)*cross}if(Math.abs(area2)<1e-9)return mean;const centroid={x:cx/(3*area2),y:cy/(3*area2)};if(polygonContains(points,centroid))return centroid;const xs=[];for(let i=0,j=points.length-1;i<points.length;j=i,i+=1){const a=points[i];const b=points[j];if(a.y>centroid.y!==b.y>centroid.y)xs.push((b.x-a.x)*(centroid.y-a.y)/(b.y-a.y)+a.x)}xs.sort((p,q)=>p-q);let best=null;for(let k=0;k+1<xs.length;k+=2){if(!best||xs[k+1]-xs[k]>best.x1-best.x0)best={x0:xs[k],x1:xs[k+1]}}return best?{x:(best.x0+best.x1)/2,y:centroid.y}:centroid}const shapeLabel=(context,at)=>{const options=context.drawing.options??{};const label=typeof options.label==="string"?options.label:"";if(label==="")return[];const labelOptions={text:label,align:"middle",valign:"middle",background:options.labelBackground??false,clamp:options.clamp!==false};return TEXT_TOOL.render({...context,points:[at],drawing:{...context.drawing,options:labelOptions}})};export const ELLIPSE_TOOL={tool:"ellipse",anchors:2,placement:"drag",render:context=>{const{points}=context;if(points.length<2)return[];const box=rectangleFromCorners(points[0],points[1]);if(!box)return[];const cx=box.x+box.width/2;const cy=box.y+box.height/2;return[{kind:"polyline",closed:true,points:ellipseOutline(cx,cy,box.width/2,box.height/2),role:"ellipse"},...shapeLabel(context,{x:cx,y:cy})]}};export const CIRCLE_TOOL={tool:"circle",anchors:2,placement:"drag",render:context=>{const{points}=context;if(points.length<2)return[];const[centre,rim]=points;const r=Math.hypot(rim.x-centre.x,rim.y-centre.y);if(r===0)return[];return[{kind:"polyline",closed:true,points:ellipseOutline(centre.x,centre.y,r,r),role:"circle"},...shapeLabel(context,centre)]}};export const POLYGON_TOOL={tool:"polygon",anchors:{min:3},placement:"poly",render:context=>{const{points}=context;if(points.length<2)return[];if(points.length===2)return[{kind:"line",x1:points[0].x,y1:points[0].y,x2:points[1].x,y2:points[1].y,role:"polygon"}];const centroid=polygonCentroid(points);return[{kind:"polyline",closed:true,points:[...points],role:"polygon"},...centroid?shapeLabel(context,centroid):[]]}};export const BUILT_IN_DRAWING_TOOLS=Object.freeze([SEGMENT_TOOL,TREND_LINE_TOOL,RAY_TOOL,EXTENDED_LINE_TOOL,HORIZONTAL_LINE_TOOL,HORIZONTAL_RAY_TOOL,VERTICAL_LINE_TOOL,CROSS_LINE_TOOL,RECTANGLE_TOOL,FIB_RETRACEMENT_TOOL,FREE_HAND_TOOL,TEXT_TOOL,ARROW_TOOL,ELLIPSE_TOOL,CIRCLE_TOOL,POLYGON_TOOL]);

package/dist/collection/components/chart/_shared/core/drawing/index.js

@@ -0,0 +1 @@
+export{DEFAULT_DRAWING_TOOL,DRAWING_HISTORY_CAP,DRAWING_SCHEMA_VERSION,DRAWING_STYLE_DEFAULTS,EMPTY_DRAWING_STATE,SEGMENT_TOOL,acceptsAnchorCount,applyDrawingAction,canRedo,canUndo,createDrawingHistory,deserializeDrawings,drawingTool,drawingToolNames,drawingsChangeDetail,drawingsToDocument,findDrawing,hasDrawingTool,historyApply,historyRedo,historyUndo,placementAnchorCount,pruneDrawingSelection,registerDrawingTool,sameDrawingSelection,resolveDrawing,resolveDrawingAnchor,resolveDrawingMode,resolveDrawingStyle,resolveDrawingStyleWithDefaults,resolveDrawingsInput,serializeDrawings}from"./drawing-contract.js";export{anchorFromPixel,convertDrawingSpace,dashArrayFor,primitiveBounds,projectDrawingAnchor,projectDrawingAnchors,renderDrawing,renderDrawings,translatedDrawingAnchors}from"./drawing-projection.js";export{BUILT_IN_DRAWING_TOOLS,CROSS_LINE_TOOL,EXTENDED_LINE_TOOL,FIB_RETRACEMENT_LEVELS,FIB_RETRACEMENT_TOOL,FREE_HAND_TOOL,HORIZONTAL_LINE_TOOL,HORIZONTAL_RAY_TOOL,ARROW_HEAD_SIZE,ARROW_HEAD_WIDTH_RATIO,ARROW_TOOL,CIRCLE_TOOL,ELLIPSE_SEGMENTS,ELLIPSE_TOOL,POLYGON_TOOL,RAY_TOOL,RECTANGLE_TOOL,TEXT_TOOL,TREND_LINE_TOOL,VERTICAL_LINE_TOOL,DEFAULT_TEXT_ANNOTATION,TEXT_ANNOTATION_PADDING,TEXT_LINE_HEIGHT,arrowHeadGeometry,ellipseOutline,extendLineToPlot,polygonCentroid,fibLevelLabel,formatDrawingValue,layoutTextAnnotation,levelLabel,rectangleFromCorners,resolveArrowHead,resolveArrowLabelAt,resolveFibExtend,resolveFibLevels,resolveLineExtension}from"./drawing-tools.js";export{DRAWING_TEXT_FONT_FAMILY,createCanvasTextMeasurer,createSvgTextMeasurer,estimateTextSize}from"./drawing-measure.js";export{DEFAULT_HIT_TOLERANCE_PX,drawingsInRect,hitTestDrawing,hitTestPrimitive,pickDrawing,rectFromPoints,textBox}from"./drawing-hit.js";export{DRAWING_HANDLE_HIT_PX,DrawingInteraction,FREE_HAND_STEP_PX,POLY_CLOSE_PX,POLY_MIN_VERTICES}from"./drawing-interaction.js";export{DRAWING_HANDLE_HOVER_PX,HANDLE_MIN_GAP_PX,drawingCursor,drawingHoverTarget,thinHandleIndices}from"./drawing-cursor.js";export{composeSvgLayers,positionSvgLayer,svgDocumentFrame,snapshotDrawingLayer,drawingsFileBaseName}from"./drawing-export.js";

package/dist/collection/components/chart/_shared/core/engine/resolve-chart-engine.js

@@ -0,0 +1 @@
+import{GPU_NO_WEBGPU_REASON,GPU_PRO_NOT_IN_BUILD_REASON}from"../adapter/gpu-availability.js";export const CHART_ENGINE_REQUESTS=["auto","standard","pro"];export const NO_PRO_RENDERER_REASON="this chart type has no WebGPU renderer";export const LICENSE_PENDING_REASON="the Chart Pro license is still being confirmed";export const LICENSE_LOAD_FAILED_REASON="the Chart Pro license module could not be loaded";export const NO_STANDARD_RENDERER_REASON="this chart type has no Standard renderer yet";export function normalizeChartEngineRequest(value){if(value===void 0||value===null)return{requested:"auto",valid:true};if(value==="auto"||value==="standard"||value==="pro")return{requested:value,valid:true};return{requested:"auto",valid:false}}export function normalizeUnavailableBehaviour(value){return value==="error"||value==="throw"?"error":"fallback"}export function isChartLicenseEngineCode(code){return code==="license-pending"||code==="license-required"||code==="load-failed"}export function chartEngineDiagnosticCode(code){return isChartLicenseEngineCode(code)||code==="module-missing"||code==="engine-unsupported"?code:void 0}function licenseBlock(state){if(state==="valid")return null;if(state==="pending")return{code:"license-pending",reason:LICENSE_PENDING_REASON};if(state==="load-failed")return{code:"load-failed",reason:LICENSE_LOAD_FAILED_REASON};return{code:"license-required",reason:`a valid Chart Pro license is required (license state: ${String(state).slice(0,32)})`}}function rendererBlock(input,licensed){if(input.moduleAvailable!==true)return{code:licensed?"module-missing":"renderer-not-in-build",reason:input.moduleReason||GPU_PRO_NOT_IN_BUILD_REASON};if(input.gpuAvailable!==true)return{code:licensed?"engine-unsupported":"gpu-unavailable",reason:input.gpuReason||GPU_NO_WEBGPU_REASON};return null}function isCount(value){return typeof value==="number"&&Number.isFinite(value)&&value>=0}function isPositive(value){return typeof value==="number"&&Number.isFinite(value)&&value>0}export function chartProThreshold(input){if(isPositive(input.proThreshold))return input.proThreshold;if(isPositive(input.defaultProThreshold))return input.defaultProThreshold;return void 0}export function chartAutoWantsPro(input){if(typeof input.autoWantsPro==="boolean")return input.autoWantsPro;const threshold=chartProThreshold(input);return threshold!==void 0&&isCount(input.dataSize)&&input.dataSize>=threshold}function lacksRequestedStandard(input,requested){return requested==="standard"&&input.hasStandardRenderer!==true}function staysStandard(input,requested){if(input.hasStandardRenderer!==true)return null;if(requested==="standard")return"ok";if(requested==="auto"&&!chartAutoWantsPro(input))return"auto-standard";return null}export function chartEngineNeedsLicense(input){switch(input.engineClass){case"pro-only":return true;case"engine-swap":{const{requested}=normalizeChartEngineRequest(input.requested);return!lacksRequestedStandard(input,requested)&&staysStandard(input,requested)===null&&rendererBlock(input,false)===null}default:return false}}export function resolveChartEngine(input){const{requested,valid}=normalizeChartEngineRequest(input.requested);const mode=normalizeUnavailableBehaviour(input.onUnavailable);const result=(effective,code,reason,licenseConsulted)=>Object.freeze({requested,requestValid:valid,effective,code,reason,licenseConsulted,shouldThrow:mode==="error"&&code!=="ok"&&code!=="auto-standard"&&!isChartLicenseEngineCode(code)&&(effective==="unavailable"||requested==="pro")});switch(input.engineClass){case"pro-only":{const license=licenseBlock(input.entitlement);if(license)return result("unavailable",license.code,license.reason,true);const renderer=rendererBlock(input,true);if(renderer)return result(input.hasStandardRenderer===true?"standard":"unavailable",renderer.code,renderer.reason,true);return result("pro","ok",null,true)}case"engine-swap":{if(lacksRequestedStandard(input,requested)){return result("unavailable","no-standard-renderer",input.noStandardRendererReason||NO_STANDARD_RENDERER_REASON,false)}const standard=staysStandard(input,requested);if(standard)return result("standard",standard,null,false);const fallback=input.hasStandardRenderer===true?"standard":"unavailable";const renderer=rendererBlock(input,false);if(renderer)return result(fallback,renderer.code,renderer.reason,false);const license=licenseBlock(input.entitlement);if(license)return result(fallback,license.code,license.reason,true);return result("pro","ok",null,true)}case"standard-only":{if(requested==="pro"||requested==="auto"&&chartAutoWantsPro(input)){return result("standard","no-pro-renderer",input.noProRendererReason||NO_PRO_RENDERER_REASON,false)}return result("standard",requested==="auto"?"auto-standard":"ok",null,false)}default:throw new TypeError(`resolveChartEngine: unknown engine class "${String(input.engineClass).slice(0,32)}".`)}}export function sameEngineOutcome(a,b){return!!a&&!!b&&a.effective===b.effective&&a.code===b.code}export function toEngineStatus(resolution,entitlement){return Object.freeze({requested:resolution.requested,effective:resolution.effective,reason:resolution.reason,code:resolution.code,entitlement:resolution.licenseConsulted&&entitlement?Object.freeze({feature:entitlement.feature,state:entitlement.state}):null})}

package/dist/collection/components/chart/_shared/core/engine/types.js

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

package/dist/collection/components/chart/_shared/core/event/hit-test.js

@@ -0,0 +1 @@
+export function _pointInRect(p,r){return p.x>=r.x&&p.x<=r.x+r.width&&p.y>=r.y&&p.y<=r.y+r.height}export function _rectsIntersect(a,b){return a.x<=b.x+b.width&&a.x+a.width>=b.x&&a.y<=b.y+b.height&&a.y+a.height>=b.y}export function _inflateRect(r,by){return{x:r.x-by,y:r.y-by,width:r.width+2*by,height:r.height+2*by}}export function _distancePointToPoint(a,b){const dx=a.x-b.x;const dy=a.y-b.y;return Math.sqrt(dx*dx+dy*dy)}export function _distancePointToSegment(p,a,b){const dx=b.x-a.x;const dy=b.y-a.y;const lenSq=dx*dx+dy*dy;if(lenSq===0){return _distancePointToPoint(p,a)}let t=((p.x-a.x)*dx+(p.y-a.y)*dy)/lenSq;if(t<0)t=0;else if(t>1)t=1;const px=a.x+t*dx;const py=a.y+t*dy;const ex=p.x-px;const ey=p.y-py;return Math.sqrt(ex*ex+ey*ey)}export function _distancePointToPath(p,path){if(path.length===0)return Infinity;if(path.length===1)return _distancePointToPoint(p,path[0]);let min=Infinity;for(let i=0;i<path.length-1;i++){const d=_distancePointToSegment(p,path[i],path[i+1]);if(d<min)min=d}return min}function coerceTolerance(value){if(typeof value!=="number"||!Number.isFinite(value)||value<0)return 0;return value}function coerceLimit(value){if(typeof value!=="number"||!Number.isFinite(value)||value<=0){return Infinity}return value}function filterFinitePath(path){const out=[];for(const p of path){if(typeof p?.x==="number"&&typeof p?.y==="number"&&Number.isFinite(p.x)&&Number.isFinite(p.y)){out.push({x:p.x,y:p.y})}}return out}function itemAnchor(item){if(item.kind==="point"){if(typeof item.x==="number"&&typeof item.y==="number"){return{x:item.x,y:item.y}}return null}if(item.bounds){return{x:item.bounds.x+item.bounds.width/2,y:item.bounds.y+item.bounds.height/2}}return null}function isItemFinite(item){if(item===null||typeof item!=="object")return false;if(item.kind==="point"){return typeof item.x==="number"&&typeof item.y==="number"&&Number.isFinite(item.x)&&Number.isFinite(item.y)}if(item.kind==="rect"){const b=item.bounds;return!!b&&Number.isFinite(b.x)&&Number.isFinite(b.y)&&Number.isFinite(b.width)&&Number.isFinite(b.height)}if(item.kind==="path"){const b=item.bounds;if(!b||!Number.isFinite(b.x)||!Number.isFinite(b.y)||!Number.isFinite(b.width)||!Number.isFinite(b.height)){return false}if(!Array.isArray(item.path)||item.path.length<1)return false;return item.path.every(point=>typeof point?.x==="number"&&typeof point?.y==="number"&&Number.isFinite(point.x)&&Number.isFinite(point.y))}return false}export function createLinearScanIndex(){const items=new Map;function size(){return items.size}function add(toAdd){if(!Array.isArray(toAdd)||toAdd.length===0)return 0;let inserted=0;let nonFiniteCount=0;let duplicateCount=0;for(const item of toAdd){if(!isItemFinite(item)){nonFiniteCount+=1;continue}if(items.has(item.id)){duplicateCount+=1;continue}items.set(item.id,item);inserted+=1}if(nonFiniteCount>0){console.warn(`[Syidax] sy-chart hit-test: ${nonFiniteCount} item(s) with non-finite coordinates dropped.`)}if(duplicateCount>0){console.warn(`[Syidax] sy-chart hit-test: ${duplicateCount} duplicate id(s) ignored.`)}return inserted}function remove(id){return items.delete(id)}function clear(){items.clear()}function testPoint(x,y,opts={}){if(!Number.isFinite(x)||!Number.isFinite(y)){console.warn("[Syidax] sy-chart hit-test: testPoint received non-finite coordinates; returning null.");return null}const tolerance=coerceTolerance(opts.tolerance);const predicate=opts.predicate;const query={x,y};let bestId=null;let bestDistance=Infinity;let bestItem=null;for(const item of items.values()){let distance;if(item.kind==="point"){const anchor=itemAnchor(item);if(anchor===null)continue;distance=_distancePointToPoint(query,anchor)}else if(item.kind==="rect"){if(!item.bounds)continue;if(_pointInRect(query,item.bounds)){distance=0}else{const cx=Math.max(item.bounds.x,Math.min(query.x,item.bounds.x+item.bounds.width));const cy=Math.max(item.bounds.y,Math.min(query.y,item.bounds.y+item.bounds.height));distance=_distancePointToPoint(query,{x:cx,y:cy})}}else if(item.kind==="path"){if(!item.path||item.path.length===0)continue;distance=_distancePointToPath(query,item.path)}else{continue}if(distance>tolerance)continue;if(predicate&&!predicate(item))continue;if(distance<bestDistance){bestDistance=distance;bestId=item.id;bestItem=item}}if(bestItem===null||bestId===null)return null;return{id:bestId,distance:bestDistance,item:bestItem}}function testRect(rect,opts={}){if(!rect||!Number.isFinite(rect.x)||!Number.isFinite(rect.y)||!Number.isFinite(rect.width)||!Number.isFinite(rect.height)){console.warn("[Syidax] sy-chart hit-test: testRect received non-finite rect; returning [].");return[]}const tolerance=coerceTolerance(opts.tolerance);const limit=coerceLimit(opts.limit);const predicate=opts.predicate;const inflated=tolerance>0?_inflateRect(rect,tolerance):rect;const queryCenter={x:rect.x+rect.width/2,y:rect.y+rect.height/2};const out=[];for(const item of items.values()){if(out.length>=limit)break;let intersects;let anchor;if(item.kind==="point"){anchor=itemAnchor(item);if(anchor===null)continue;intersects=_pointInRect(anchor,inflated)}else{if(!item.bounds)continue;intersects=_rectsIntersect(inflated,item.bounds);anchor=itemAnchor(item)}if(!intersects)continue;if(predicate&&!predicate(item))continue;const distance=anchor!==null?_distancePointToPoint(queryCenter,anchor):0;out.push({id:item.id,distance,item})}return out}function testPath(path,opts={}){if(!Array.isArray(path)||path.length===0)return[];const finitePath=filterFinitePath(path);if(finitePath.length<2)return[];const tolerance=coerceTolerance(opts.tolerance);const limit=coerceLimit(opts.limit);const predicate=opts.predicate;const seen=new Set;const out=[];for(let i=0;i<finitePath.length-1&&out.length<limit;i++){const a=finitePath[i];const b=finitePath[i+1];for(const item of items.values()){if(out.length>=limit)break;if(seen.has(item.id))continue;let distance;if(item.kind==="point"){const anchor=itemAnchor(item);if(anchor===null)continue;distance=_distancePointToSegment(anchor,a,b)}else if(item.kind==="rect"){if(!item.bounds)continue;const center={x:item.bounds.x+item.bounds.width/2,y:item.bounds.y+item.bounds.height/2};const segRect={x:Math.min(a.x,b.x),y:Math.min(a.y,b.y),width:Math.abs(b.x-a.x),height:Math.abs(b.y-a.y)};const inflatedBounds=tolerance>0?_inflateRect(item.bounds,tolerance):item.bounds;if(!_rectsIntersect(segRect,inflatedBounds)){continue}distance=_distancePointToSegment(center,a,b)}else if(item.kind==="path"){if(!item.bounds||!item.path||item.path.length===0)continue;const segRect={x:Math.min(a.x,b.x),y:Math.min(a.y,b.y),width:Math.abs(b.x-a.x),height:Math.abs(b.y-a.y)};const inflatedBounds=tolerance>0?_inflateRect(item.bounds,tolerance):item.bounds;if(!_rectsIntersect(segRect,inflatedBounds))continue;const center={x:item.bounds.x+item.bounds.width/2,y:item.bounds.y+item.bounds.height/2};distance=_distancePointToSegment(center,a,b)}else{continue}if(distance>tolerance)continue;if(predicate&&!predicate(item))continue;seen.add(item.id);out.push({id:item.id,distance,item})}}return out}return{testPoint,testRect,testPath,size,add,remove,clear}}

package/dist/collection/components/chart/_shared/core/event/index.js

@@ -0,0 +1 @@
+export{getPointerKind,normalisePointerEvent}from"./pointer.js";export{_distancePointToPath,_distancePointToPoint,_distancePointToSegment,_inflateRect,_pointInRect,_rectsIntersect,createLinearScanIndex}from"./hit-test.js";export{buildChartPointContextMenuDetail,rebaseChartPointContextMenuDetail,seriesDetailFromPoint}from"./point-context-menu.js";

package/dist/collection/components/chart/_shared/core/event/point-context-menu.js

@@ -0,0 +1 @@
+export function seriesDetailFromPoint(point,fallback={index:0}){const pointLike=point&&typeof point==="object"?point:{};const index=typeof pointLike.seriesIndex==="number"&&Number.isFinite(pointLike.seriesIndex)?Math.trunc(pointLike.seriesIndex):fallback.index;return{index,id:pointLike.seriesId??fallback.id,name:pointLike.seriesName??fallback.name}}export function buildChartPointContextMenuDetail(event,host,chartType,point,series){const rect=host.getBoundingClientRect();return{chartType,x:Math.round(event.clientX-rect.left),y:Math.round(event.clientY-rect.top),clientX:Math.round(event.clientX),clientY:Math.round(event.clientY),point,series:seriesDetailFromPoint(point,series)}}export function rebaseChartPointContextMenuDetail(detail,host,chartType=detail.chartType){const rect=host.getBoundingClientRect();return{...detail,chartType,x:Math.round(detail.clientX-rect.left),y:Math.round(detail.clientY-rect.top)}}

package/dist/collection/components/chart/_shared/core/event/pointer.js

@@ -0,0 +1 @@
+function coerceFinite(value,fieldName,badFields){if(typeof value==="number"&&Number.isFinite(value)){return value}badFields.push(fieldName);return 0}function detectKind(event){if(event&&typeof event==="object"&&"pointerType"in event){const pt=event.pointerType;if(pt==="mouse"||pt==="touch"||pt==="pen")return pt;return"mouse"}if(event&&typeof event==="object"&&"touches"in event){return"touch"}return"mouse"}function pickTouch(event,touchIndex){const touches=event.touches;if(touches&&touchIndex>=0&&touchIndex<touches.length){return touches[touchIndex]}const changed=event.changedTouches;if(changed&&touchIndex>=0&&touchIndex<changed.length){return changed[touchIndex]}return null}function resolveTarget(event,override){if(override)return override;const t=event.target;if(t&&t.getBoundingClientRect)return t;const ct=event.currentTarget;if(ct&&ct.getBoundingClientRect)return ct;return null}export function getPointerKind(event){if(event===null||event===void 0)return"mouse";return detectKind(event)}export function normalisePointerEvent(event,opts={}){if(event===null||event===void 0)return null;const kind=detectKind(event);const touchIndex=opts.touchIndex??0;const badFields=[];let clientX;let clientY;let pageX;let pageY;let offsetX;let offsetY;let buttons;let pointerId;let pressure;let tilt;const isPointerEvent=typeof event==="object"&&event!==null&&"pointerType"in event;const isTouchEvent=!isPointerEvent&&typeof event==="object"&&event!==null&&"touches"in event;if(isTouchEvent){const touchEv=event;const touch=pickTouch(touchEv,touchIndex);if(touch===null)return null;clientX=coerceFinite(touch.clientX,"clientX",badFields);clientY=coerceFinite(touch.clientY,"clientY",badFields);pageX=coerceFinite(touch.pageX,"pageX",badFields);pageY=coerceFinite(touch.pageY,"pageY",badFields);const target=resolveTarget(event,opts.target);if(target===null){offsetX=0;offsetY=0;console.warn("[Syidax] sy-chart pointer: TouchEvent target has no getBoundingClientRect; offset coerced to 0/0.")}else{const rect=target.getBoundingClientRect();offsetX=clientX-rect.left;offsetY=clientY-rect.top}const anyActive=touchEv.touches&&touchEv.touches.length>0||touchEv.changedTouches&&touchEv.changedTouches.length>0;buttons=anyActive?1:0;pointerId=typeof touch.identifier==="number"&&Number.isFinite(touch.identifier)?touch.identifier:null;pressure=.5;tilt=null}else if(isPointerEvent){const pe=event;clientX=coerceFinite(pe.clientX,"clientX",badFields);clientY=coerceFinite(pe.clientY,"clientY",badFields);pageX=coerceFinite(pe.pageX,"pageX",badFields);pageY=coerceFinite(pe.pageY,"pageY",badFields);if(opts.target){const rect=opts.target.getBoundingClientRect();offsetX=clientX-rect.left;offsetY=clientY-rect.top}else{offsetX=coerceFinite(pe.offsetX,"offsetX",badFields);offsetY=coerceFinite(pe.offsetY,"offsetY",badFields)}buttons=typeof pe.buttons==="number"&&Number.isFinite(pe.buttons)?pe.buttons:0;pointerId=typeof pe.pointerId==="number"&&Number.isFinite(pe.pointerId)?pe.pointerId:null;pressure=typeof pe.pressure==="number"&&Number.isFinite(pe.pressure)?pe.pressure:0;if(kind==="pen"){const tx=typeof pe.tiltX==="number"&&Number.isFinite(pe.tiltX)?pe.tiltX:0;const ty=typeof pe.tiltY==="number"&&Number.isFinite(pe.tiltY)?pe.tiltY:0;tilt={x:tx,y:ty}}else{tilt=null}}else{const me=event;clientX=coerceFinite(me.clientX,"clientX",badFields);clientY=coerceFinite(me.clientY,"clientY",badFields);pageX=coerceFinite(me.pageX,"pageX",badFields);pageY=coerceFinite(me.pageY,"pageY",badFields);if(opts.target){const rect=opts.target.getBoundingClientRect();offsetX=clientX-rect.left;offsetY=clientY-rect.top}else{offsetX=coerceFinite(me.offsetX,"offsetX",badFields);offsetY=coerceFinite(me.offsetY,"offsetY",badFields)}buttons=typeof me.buttons==="number"&&Number.isFinite(me.buttons)?me.buttons:0;pointerId=null;pressure=buttons>0?.5:0;tilt=null}if(badFields.length>0){console.warn(`[Syidax] sy-chart pointer: non-finite ${badFields.join(", ")}; coerced to 0.`)}return{kind,clientX,clientY,pageX,pageY,offsetX,offsetY,buttons,pointerId,pressure,tilt,originalEvent:event}}

package/dist/collection/components/chart/_shared/core/export/chart-export.js

@@ -0,0 +1,2 @@
+const INLINED_STYLE_PROPS=["fill","fill-opacity","stroke","stroke-width","stroke-opacity","stroke-dasharray","stroke-linecap","stroke-linejoin","opacity","color","font-family","font-size","font-weight","font-style","text-anchor","dominant-baseline","letter-spacing","visibility","display"];export function clampExportScale(scale){const s=typeof scale==="number"&&Number.isFinite(scale)?scale:2;return Math.max(1,Math.min(8,s))}export function exportMimeType(format){if(format==="png")return"image/png";if(format==="svg")return"image/svg+xml";if(format==="json")return"application/json";return"text/csv"}export function chartExportFilename(base,ext){const slug=(base||"chart").trim().replace(/[\\/:*?"<>|]+/g,"-").replace(/\s+/g,"-").replace(/-+/g,"-").replace(/^-|-$/g,"").toLowerCase();return`${slug||"chart"}.${ext}`}export function ensureSvgNamespaces(markup,width,height){let out=markup.trim();if(!/^<\?xml/.test(out))out=`<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+${out}`;if(!/xmlns="http:\/\/www\.w3\.org\/2000\/svg"/.test(out)){out=out.replace(/<svg\b/,'<svg xmlns="http://www.w3.org/2000/svg"')}if(!/xmlns:xlink=/.test(out)){out=out.replace(/<svg\b/,'<svg xmlns:xlink="http://www.w3.org/1999/xlink"')}if(width&&height&&!/<svg[^>]*\bwidth=/.test(out)){out=out.replace(/<svg\b/,`<svg width="${width}" height="${height}"`)}return out}export function svgMarkupToDataUri(markup){return`data:image/svg+xml;charset=utf-8,${encodeURIComponent(markup)}`}export function wrapRasterAsSvg(dataUrl,options){const{width,height}=options;const bg=options.background?`<rect width="${width}" height="${height}" fill="${options.background}"/>`:"";const markup=`<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="${width}" height="${height}" viewBox="0 0 ${width} ${height}">`+bg+`<image x="0" y="0" width="${width}" height="${height}" preserveAspectRatio="none" xlink:href="${dataUrl}"/></svg>`;return ensureSvgNamespaces(markup,width,height)}const layerPx=value=>String(Number.isFinite(value)?Math.round(value*100)/100:0);export function positionSvgLayer(layer){const markup=layer.markup.trim().replace(/^<\?xml[^>]*\?>\s*/i,"");const open=markup.match(/^<svg\b([^>]*)>/i);if(!open)return"";const selfClosing=/\/\s*$/.test(open[1]);const attrs=open[1].replace(/\/\s*$/,"").replace(/\s(?:x|y|width|height|style|aria-hidden|overflow)="[^"]*"/g,"");const head=`<svg${attrs} x="${layerPx(layer.x)}" y="${layerPx(layer.y)}" width="${layerPx(layer.width)}" height="${layerPx(layer.height)}" overflow="hidden">`;return head+(selfClosing?"</svg>":markup.slice(open[0].length))}export function composeSvgLayers(base,layers){const close=base.lastIndexOf("</svg>");if(close<0)return base;const inner=layers.map(positionSvgLayer).filter(markup=>markup.length>0).join("");if(!inner)return base;return`${base.slice(0,close)}${inner}${base.slice(close)}`}export function svgDocumentFrame(width,height,background){const bg=background?`<rect width="${width}" height="${height}" fill="${background}"/>`:"";const markup=`<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="${width}" height="${height}" viewBox="0 0 ${width} ${height}">${bg}</svg>`;return ensureSvgNamespaces(markup,width,height)}export function serializeSvgElement(svg,options={}){if(typeof document==="undefined"||!svg)return null;const clone=svg.cloneNode(true);const live=svg.querySelectorAll("*");const cloned=clone.querySelectorAll("*");const view=svg.ownerDocument?.defaultView??(typeof window!=="undefined"?window:null);if(view){for(let i=0;i<live.length;i+=1){const computed=view.getComputedStyle(live[i]);const target=cloned[i];if(!target)continue;for(const prop of INLINED_STYLE_PROPS){const value=computed.getPropertyValue(prop);if(value)target.style.setProperty(prop,value)}}}const width=options.width??svg.clientWidth??Number(svg.getAttribute("width"))??void 0;const height=options.height??svg.clientHeight??Number(svg.getAttribute("height"))??void 0;if(width&&height){clone.setAttribute("width",String(width));clone.setAttribute("height",String(height))}if(options.background){const rect=svg.ownerDocument.createElementNS("http://www.w3.org/2000/svg","rect");rect.setAttribute("width","100%");rect.setAttribute("height","100%");rect.setAttribute("fill",options.background);clone.insertBefore(rect,clone.firstChild)}const markup=new XMLSerializer().serializeToString(clone);return ensureSvgNamespaces(markup,width,height)}function loadImage(src){return new Promise((resolveImg,reject)=>{const img=new Image;img.onload=()=>resolveImg(img);img.onerror=()=>reject(new Error("Chart export: image source failed to load."));img.decoding="async";img.src=src})}function canvasToBlob(canvas,mimeType,quality){return new Promise((resolveBlob,reject)=>{canvas.toBlob(blob=>blob?resolveBlob(blob):reject(new Error("Chart export: canvas.toBlob returned null.")),mimeType,quality)})}export async function rasterizeToPngBlob(imageSrc,options){if(typeof document==="undefined")throw new Error("Chart export: PNG rasterisation needs a DOM.");const scale=clampExportScale(options.scale);const canvas=document.createElement("canvas");canvas.width=Math.round(options.width*scale);canvas.height=Math.round(options.height*scale);const ctx=canvas.getContext("2d");if(!ctx)throw new Error("Chart export: 2D context unavailable.");if(options.background){ctx.fillStyle=options.background;ctx.fillRect(0,0,canvas.width,canvas.height)}const img=await loadImage(imageSrc);ctx.drawImage(img,0,0,canvas.width,canvas.height);return canvasToBlob(canvas,options.mimeType??"image/png",options.quality)}export async function canvasToPngBlob(source,options){if(typeof document==="undefined")throw new Error("Chart export: PNG export needs a DOM.");const scale=clampExportScale(options.scale);const out=document.createElement("canvas");out.width=Math.round(source.width*scale/(window.devicePixelRatio||1))||source.width;out.height=Math.round(source.height*scale/(window.devicePixelRatio||1))||source.height;const ctx=out.getContext("2d");if(!ctx)throw new Error("Chart export: 2D context unavailable.");if(options.background){ctx.fillStyle=options.background;ctx.fillRect(0,0,out.width,out.height)}ctx.drawImage(source,0,0,out.width,out.height);return canvasToBlob(out,options.mimeType??"image/png",options.quality)}export function triggerDownload(payload,filename,mimeType){if(typeof document==="undefined")return;const blob=payload instanceof Blob?payload:new Blob([payload],{type:mimeType??"text/plain;charset=utf-8"});const url=URL.createObjectURL(blob);const anchor=document.createElement("a");anchor.href=url;anchor.download=filename;anchor.rel="noopener";anchor.style.display="none";document.body.appendChild(anchor);anchor.click();document.body.removeChild(anchor);setTimeout(()=>URL.revokeObjectURL(url),0)}

package/dist/collection/components/chart/_shared/core/export/data-table.js

@@ -0,0 +1 @@
+import{resolveFinancialBars}from"../financial-bars.js";const TYPED=v=>v instanceof Float32Array||v instanceof Float64Array||v instanceof Int32Array||v instanceof Int16Array||v instanceof Uint8Array||v instanceof Uint16Array||v instanceof Uint32Array;function num(v){if(typeof v==="number"&&Number.isFinite(v))return v;return null}function datumScalar(d){if(typeof d==="number")return Number.isFinite(d)?d:null;if(d&&typeof d==="object"){const o=d;return num(o.value)??num(o.y)}return null}function datumXY(d){if(d&&typeof d==="object"){const o=d;const x=num(o.x);const y=num(o.y);if(x!==null&&y!==null)return{x,y}}if(Array.isArray(d)&&d.length>=2){const x=num(d[0]);const y=num(d[1]);if(x!==null&&y!==null)return{x,y}}return null}function datumName(d,fallback){if(d&&typeof d==="object"){const o=d;if(typeof o.name==="string")return o.name;if(typeof o.id==="string")return o.id}return fallback}function toScalarArray(raw){if(TYPED(raw)){const out=[];for(let i=0;i<raw.length;i+=1)out.push(Number.isFinite(raw[i])?raw[i]:null);return out}if(Array.isArray(raw))return raw.map(datumScalar);return[]}function isXYArray(raw){return Array.isArray(raw)&&raw.length>0&&raw.every(d=>datumXY(d)!==null)}function normalizeSeries(input){const explicit=Array.isArray(input.series)&&input.series||Array.isArray(input.data)&&input.data||null;if(explicit){const looksLikeSeries=explicit.some(s=>s&&typeof s==="object"&&("data"in s||"values"in s));if(looksLikeSeries){return explicit.map((s,i)=>{const o=s;const raw2=o.values??o.data;const name2=typeof o.name==="string"?o.name:`Series ${i+1}`;return isXYArray(raw2)?{name:name2,scalars:[],xy:raw2.map(d=>datumXY(d))}:{name:name2,scalars:toScalarArray(raw2)}})}}const raw=input.values??input.data;const name=input.seriesName??"Series 1";if(isXYArray(raw))return[{name,scalars:[],xy:raw.map(d=>datumXY(d))}];return[{name,scalars:toScalarArray(raw)}]}function categoryLabels(input,count){const cats=input.categories;const out=[];for(let i=0;i<count;i+=1)out.push(cats&&cats[i]!=null?String(cats[i]):String(i+1));return out}const POLAR_SLICE=new Set(["pie","donut","funnel","pyramid","item"]);function sliceTable(input){const raw=Array.isArray(input.values)&&input.values||Array.isArray(input.data)&&input.data||[];const entries=raw.map((d,i)=>({name:datumName(d,`Item ${i+1}`),value:datumScalar(d)??0}));const total=entries.reduce((sum,e)=>sum+(e.value>0?e.value:0),0);return{columns:["Category","Value","Percentage"],rows:entries.map(e=>[e.name,e.value,total>0?Number((e.value/total*100).toFixed(2)):0])}}function gaugeTable(input){const value=num(input.value);return{columns:["Metric","Value"],rows:[["Value",value]]}}function seriesTable(input){const series=normalizeSeries(input);const scatter=series.some(s=>s.xy&&s.xy.length>0);if(scatter){const columns2=["Series","X","Y"];const rows2=[];for(const s of series)for(const p of s.xy??[])rows2.push([s.name,p.x,p.y]);return{columns:columns2,rows:rows2}}const maxLen=series.reduce((m,s)=>Math.max(m,s.scalars.length),0);const labels=categoryLabels(input,maxLen);const columns=["Category",...series.map(s=>s.name)];const rows=[];for(let i=0;i<maxLen;i+=1){rows.push([labels[i],...series.map(s=>i<s.scalars.length?s.scalars[i]:null)])}return{columns,rows}}function rawArray(input){if(Array.isArray(input.values))return input.values;if(Array.isArray(input.data))return input.data;return[]}function tilemapTable(input){const raw=rawArray(input);const entries=raw.map((d,i)=>{const o=d??{};const name=typeof o.name==="string"?o.name:typeof o.label==="string"?o.label:null;return{name,x:num(o.x),y:num(o.y),value:num(o.value),fallback:`Cell ${i+1}`}});const named=entries.some(e=>e.name!==null);return{columns:named?["Name","X","Y","Value"]:["X","Y","Value"],rows:entries.map(e=>named?[e.name??e.fallback,e.x,e.y,e.value]:[e.x,e.y,e.value])}}function waferTable(input){const raw=rawArray(input);const entries=raw.map(d=>{const o=d??{};const bin=typeof o.bin==="string"?o.bin:num(o.bin);return{col:num(o.col),row:num(o.row),bin,value:num(o.value)}});const hasBin=entries.some(e=>e.bin!==null);const hasValue=entries.some(e=>e.value!==null);const columns=["Col","Row"];if(hasBin||!hasValue)columns.push("Bin");if(hasValue)columns.push("Value");return{columns,rows:entries.map(e=>{const row=[e.col,e.row];if(hasBin||!hasValue)row.push(e.bin);if(hasValue)row.push(e.value);return row})}}function wordCloudTable(input){const raw=rawArray(input);return{columns:["Word","Weight"],rows:raw.map((d,i)=>{const o=d??{};const word=typeof o.name==="string"?o.name:typeof o.text==="string"?o.text:`Word ${i+1}`;return[word,num(o.weight)]})}}function variwideTable(input){const raw=rawArray(input);const labels=categoryLabels(input,raw.length);return{columns:["Category","Value","Weight"],rows:raw.map((d,i)=>{const o=d??{};const label=typeof o.category==="string"?o.category:typeof o.label==="string"?o.label:typeof o.name==="string"?o.name:labels[i];return[label,typeof d==="number"?d:num(o.value),num(o.weight)]})}}function dumbbellTable(input){const raw=rawArray(input);const labels=categoryLabels(input,raw.length);const pairs=raw.map((d,i)=>{const o=d??{};const label=typeof o.label==="string"?o.label:typeof o.category==="string"?o.category:typeof o.name==="string"?o.name:labels[i];return{label,low:num(o.low),high:num(o.high)}});if(pairs.some(p=>p.low!==null||p.high!==null)){return{columns:["Category","Low","High"],rows:pairs.map(p=>[p.label,p.low,p.high])}}return seriesTable(input)}function chordTable(input){const data=input.data??input.values;const links=Array.isArray(data)?data:data&&typeof data==="object"&&Array.isArray(data.links)?data.links:[];const rows=[];const positions=new Map;for(const raw of links){const link=raw&&typeof raw==="object"?raw:void 0;const source=Array.isArray(raw)?raw[0]:link?.source;const target=Array.isArray(raw)?raw[1]:link?.target;const value=Array.isArray(raw)?raw[2]:link?.value;if(typeof source!=="string"||source.trim().length===0||typeof target!=="string"||target.trim().length===0||typeof value!=="number"||!Number.isFinite(value)||value<0)continue;const key=JSON.stringify([source,target]);const row=[source,target,value];const index=positions.get(key);if(index===void 0){positions.set(key,rows.length);rows.push(row)}else rows[index]=row}return{columns:["Source","Target","Value"],rows}}function networkGraphTable(input){const data=input.data??input.values;const graph=data&&typeof data==="object"&&!Array.isArray(data)?data:void 0;const links=Array.isArray(data)?data:Array.isArray(graph?.links)?graph.links:[];const validId=value=>typeof value==="string"&&value.trim().length>0;const merged=new Map;for(const raw of links){const object=raw&&typeof raw==="object"&&!Array.isArray(raw)?raw:void 0;const source=Array.isArray(raw)?raw[0]:object?.source;const target=Array.isArray(raw)?raw[1]:object?.target;const weight=Array.isArray(raw)?raw[2]:object?.value;const value=weight===void 0?1:weight;if(!validId(source)||!validId(target)||typeof value!=="number"||!Number.isFinite(value)||value<0)continue;if(object?.id!==void 0&&!validId(object.id))continue;const id=validId(object?.id)?object.id:null;const key=JSON.stringify(id===null?["pair",source,target]:["id",id]);merged.set(key,{id,source,target,value})}const nodes=new Map;const addNode=(id,label)=>{const prior=nodes.get(id);if(prior){if(label!==void 0)prior.label=label}else nodes.set(id,{label:label??id,incoming:0,outgoing:0})};for(const raw of Array.isArray(graph?.nodes)?graph.nodes:[]){const object=raw&&typeof raw==="object"&&!Array.isArray(raw)?raw:void 0;const id=typeof raw==="string"?raw:object?.id;if(validId(id))addNode(id,typeof object?.label==="string"?object.label:void 0)}const add=(a,b)=>Math.min(Number.MAX_VALUE,a+b);for(const edge of merged.values()){addNode(edge.source);addNode(edge.target);const source=nodes.get(edge.source);const target=nodes.get(edge.target);source.outgoing=add(source.outgoing,edge.value);target.incoming=add(target.incoming,edge.value)}return{columns:["Kind","Id","Label","Source","Target","Value"],rows:[...Array.from(nodes,([id,node])=>["node",id,node.label,null,null,add(node.incoming,node.outgoing)]),...Array.from(merged,([key,edge])=>["link",edge.id??key,null,edge.source,edge.target,edge.value])]}}export function buildChartDataTable(input){const type=input.type??"line";if(type==="candlestick"||type==="ohlc"){const bars=resolveFinancialBars(input.data??input.values);return{columns:["Time (ms)","Open","High","Low","Close","Volume"],rows:bars.map(bar=>[bar.time,bar.open,bar.high,bar.low,bar.close,bar.volume??null])}}if(type==="gauge")return gaugeTable(input);if(POLAR_SLICE.has(type))return sliceTable(input);if(type==="tilemap")return tilemapTable(input);if(type==="wafer-map")return waferTable(input);if(type==="word-cloud")return wordCloudTable(input);if(type==="variwide")return variwideTable(input);if(type==="dumbbell")return dumbbellTable(input);if(type==="chord"||type==="sankey")return chordTable(input);if(type==="network-graph")return networkGraphTable(input);return seriesTable(input)}function csvCell(value,opts){if(value===null||value===void 0)return"";let text=typeof value==="number"?String(value):value;if(typeof value==="number"&&opts.decimalPoint!==".")text=text.replace(".",opts.decimalPoint);const mustQuote=text.includes(opts.itemDelimiter)||text.includes('"')||/[\r\n]/.test(text);return mustQuote?`"${text.replace(/"/g,'""')}"`:text}export function dataTableToCsv(table,options={}){const opts={itemDelimiter:options.itemDelimiter??",",lineDelimiter:options.lineDelimiter??"\n",decimalPoint:options.decimalPoint??".",withBom:options.withBom??false};const lines=[table.columns.map(c=>csvCell(c,opts)).join(opts.itemDelimiter)];for(const row of table.rows)lines.push(row.map(cell=>csvCell(cell,opts)).join(opts.itemDelimiter));const body=lines.join(opts.lineDelimiter);return opts.withBom?`\uFEFF${body}`:body}function escapeHtml(text){return text.replace(/&/g,"&amp;").replace(/</g,"&lt;").replace(/>/g,"&gt;").replace(/"/g,"&quot;")}export function dataTableToHtml(table,caption){const cellStyle="padding:5px 10px;border-bottom:1px solid var(--sy-grid-line-color,#e5e7eb);white-space:nowrap;";const head=table.columns.map((c,i)=>`<th scope="col" style="${cellStyle}text-align:${i===0?"left":"right"}">${escapeHtml(String(c))}</th>`).join("");const body=table.rows.map(row=>{const cells=row.map((cell,i)=>i===0?`<th scope="row" style="${cellStyle}text-align:left">${escapeHtml(cell==null?"":String(cell))}</th>`:`<td style="${cellStyle}text-align:right">${escapeHtml(cell==null?"":String(cell))}</td>`).join("");return`<tr>${cells}</tr>`}).join("");const cap=caption?`<caption>${escapeHtml(caption)}</caption>`:"";return`<table class="sy-chart__data-table" style="border-collapse:collapse;width:100%;font-size:12px;color:var(--sy-axis-color,#111827)">${cap}<thead style="position:sticky;top:0;background:var(--sy-chart-bg,#fff)"><tr>${head}</tr></thead><tbody>${body}</tbody></table>`}

package/dist/collection/components/chart/_shared/core/export/html-overlay.js

@@ -0,0 +1 @@
+export function fitOverlayText(text,width,measure){if(!(width>0))return"";if(measure(text)<=width)return text;if(measure("…")>width)return"";const chars=Array.from(text);let lo=0,hi=chars.length;while(lo<hi){const mid=Math.ceil((lo+hi)/2);if(measure(chars.slice(0,mid).join("")+"…")<=width)lo=mid;else hi=mid-1}return chars.slice(0,lo).join("")+"…"}const px=value=>(Math.round(value*100)/100).toString();export function escapeSvgText(text){return text.replace(/&/g,"&amp;").replace(/</g,"&lt;").replace(/>/g,"&gt;").replace(/"/g,"&quot;")}function escapeAttr(value){return escapeSvgText(value).replace(/'/g,"&#39;")}export function isRenderableOverlayItem(item,frame){if(!(item.width>0)||!(item.height>0))return false;if(item.x+item.width<=0||item.y+item.height<=0||item.x>=frame.width||item.y>=frame.height)return false;if(item.opacity!==void 0&&!(item.opacity>0))return false;if(item.kind==="text")return typeof item.text==="string"&&item.text.trim().length>0;return typeof item.color==="string"&&item.color.length>0&&!/^rgba\(\s*\d+\s*,\s*\d+\s*,\s*\d+\s*,\s*0\s*\)$/.test(item.color)&&item.color!=="transparent"}export function renderHtmlOverlayItem(item){if(item.kind==="text"&&item.background){return renderHtmlOverlayItem({...item,kind:"rect",color:item.background,background:void 0})+renderHtmlOverlayItem({...item,background:void 0})}if(item.clip&&item.kind==="text"){return`<svg x="${px(item.x)}" y="${px(item.y)}" width="${px(item.width)}" height="${px(item.height)}" overflow="hidden" data-label-clip="true">${renderHtmlOverlayItem({...item,x:0,y:0,clip:false})}</svg>`}const opacity=item.opacity!==void 0&&item.opacity<1?` opacity="${px(item.opacity)}"`:"";if(item.kind==="rect"){return`<rect x="${px(item.x)}" y="${px(item.y)}" width="${px(item.width)}" height="${px(item.height)}" fill="${escapeAttr(item.color)}"${opacity}/>`}const align=item.align??"start";const cx=item.x+item.width/2;const cy=item.y+item.height/2;const x=align==="end"?item.x+item.width:align==="middle"?cx:item.x;const font=[item.fontSize!==void 0?`font-size="${px(item.fontSize)}"`:"",item.fontFamily?`font-family="${escapeAttr(item.fontFamily)}"`:"",item.fontWeight&&item.fontWeight!=="400"&&item.fontWeight!=="normal"?`font-weight="${escapeAttr(item.fontWeight)}"`:"",item.fontStyle&&item.fontStyle!=="normal"?`font-style="${escapeAttr(item.fontStyle)}"`:""].filter(Boolean).join(" ");const rotate=item.rotate?` transform="rotate(${px(item.rotate)} ${px(cx)} ${px(cy)})"`:"";const halo=item.haloColor&&Number.isFinite(item.haloWidth)&&item.haloWidth>0?` stroke="${escapeAttr(item.haloColor)}" stroke-width="${px(item.haloWidth)}" stroke-linejoin="round" paint-order="stroke fill"`:"";return`<text x="${px(x)}" y="${px(cy)}" text-anchor="${align}" dominant-baseline="central" fill="${escapeAttr(item.color)}"${font?` ${font}`:""}${opacity}${rotate}${halo}>${escapeSvgText(item.text??"")}</text>`}export function renderHtmlOverlayLayer(items,layer,frame){const own=items.filter(item=>item.layer===layer&&isRenderableOverlayItem(item,frame));if(own.length===0)return null;const width=Math.max(1,Math.round(frame.width));const height=Math.max(1,Math.round(frame.height));return`<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}" viewBox="0 0 ${width} ${height}" data-html-overlay="${layer}">${own.map(renderHtmlOverlayItem).join("")}</svg>`}export const HTML_OVERLAY_SELECTOR=['[class*="__grid-line"]','[class*="__axis-line"]','[class*="__axis-label"]','[class*="__axis-title"]','[class*="__month-label"]','[class*="__weekday-label"]',"[data-chart-export-label]",'[class*="__title"]','[class*="__subtitle"]'].join(", ");export function rotationOfTransform(transform){const m=/^matrix\(\s*([-\d.e]+)\s*,\s*([-\d.e]+)\s*,/.exec(transform??"");if(!m)return 0;const a=Number(m[1]);const b=Number(m[2]);if(!Number.isFinite(a)||!Number.isFinite(b))return 0;const deg=Math.atan2(b,a)*180/Math.PI;return Math.abs(deg)<1e-6?0:Math.round(deg*100)/100}export function overlayItemOfElement(el,origin,scale){if(el.style.display==="none"||el.style.visibility==="hidden")return null;const width=el.rect.width*scale;const height=el.rect.height*scale;if(!(width>0)||!(height>0))return null;const x=(el.rect.left-origin.x)*scale;const y=(el.rect.top-origin.y)*scale;const opacity=Number.parseFloat(el.style.opacity);const base={x,y,width,height,opacity:Number.isFinite(opacity)?opacity:void 0};const isLine=/__grid-line|__axis-line/.test(el.className);const text=(el.textContent??"").trim();if(isLine||text.length===0){if(!el.style.backgroundColor)return null;return{kind:"rect",layer:"under",...base,color:el.style.backgroundColor}}const rotate=rotationOfTransform(el.style.transform);const size=Number.parseFloat(el.style.fontSize);return{kind:"text",layer:"over",...base,text,color:el.style.color,...isRenderableOverlayItem({kind:"rect",layer:"over",...base,color:el.style.backgroundColor},{width:Infinity,height:Infinity})?{background:el.style.backgroundColor}:{},fontSize:Number.isFinite(size)?size*scale:void 0,fontFamily:el.style.fontFamily||void 0,fontWeight:el.style.fontWeight||void 0,fontStyle:el.style.fontStyle||void 0,align:rotate?"middle":el.style.textAlign==="right"||el.style.textAlign==="end"?"end":el.style.textAlign==="center"?"middle":"start",rotate:rotate||void 0,...el.haloColor?{haloColor:el.haloColor,haloWidth:2*scale,clip:true}:{}}}

package/dist/collection/components/chart/_shared/core/export/index.js

@@ -0,0 +1 @@
+export*from"./chart-export.js";export*from"./data-table.js";

package/dist/collection/components/chart/_shared/core/export/svg-fonts.js

@@ -0,0 +1 @@
+const unquote=text=>text.trim().replace(/^(["'])(.*)\1$/,"$2").toLowerCase();export function svgFontFamilies(value){return(value.match(/"[^"\r\n]*"|'[^'\r\n]*'|[^,]+/g)??[]).map(unquote).filter(Boolean)}const descriptor=(value,kind)=>{const text=value.toLowerCase().replace(/\s+/g,"");if(kind==="weight")return text==="normal"||!text?"400":text==="bold"?"700":text;return text||(kind==="unicodeRange"?"u+0-10ffff":"normal")};export function collectSvgFontRules(sheets,families,loaded,baseUrl=""){const result=[],visited=new Set;const visit=sheet=>{if(visited.has(sheet)||sheet.disabled)return;visited.add(sheet);let rules;try{rules=sheet.cssRules}catch{return}const read=rules2=>{for(const rule of Array.from(rules2)){if(rule.type===3){const imported=rule.styleSheet;if(imported)visit(imported)}else if(rule.type===5){const style=rule.style,family=unquote(style.getPropertyValue("font-family"));if(!families.has(family))continue;if(loaded&&!loaded.some(face=>face.status==="loaded"&&unquote(face.family)===family&&["style","weight","stretch","unicodeRange"].every(key=>descriptor(face[key],key)===descriptor(style.getPropertyValue(key==="unicodeRange"?"unicode-range":"font-"+key),key))))continue;const source=style.getPropertyValue("src");if(/url\(/i.test(source))result.push({cssText:Array.from(style).filter(name=>name!=="src").map(name=>name+":"+style.getPropertyValue(name)+";").join(""),source,baseUrl:sheet.href||baseUrl})}else if("cssRules"in rule)read(rule.cssRules)}};read(rules)};sheets.forEach(visit);return result}export async function inlineSvgFontRules(rules,fetchFont){const cache=new Map;const declarations=await Promise.all(rules.map(async rule=>{const urls=[...rule.source.matchAll(/url\(\s*(?:"([^"\r\n]*)"|'([^'\r\n]*)'|([^)]*?))\s*\)/gi)].map(match=>match[1]??match[2]??match[3]);let embedded;for(const raw of urls){const url=new URL(raw.trim(),rule.baseUrl).href;if(!/^(https?:|blob:|data:)/i.test(url))continue;try{if(!cache.has(url))cache.set(url,url.startsWith("data:")?Promise.resolve(url):fetchFont(url));embedded=await cache.get(url);break}catch{}}if(!embedded)throw new Error("Chart export: a loaded web font could not be embedded. Check font URL access/CORS or use a system font.");return"@font-face{"+rule.cssText+';src:url("'+embedded.replace(/"/g,"%22")+'");}'}));return declarations.join("\n")}async function fetchFontData(url){const controller=new AbortController,timeout=setTimeout(()=>controller.abort(),1e4);try{const response=await fetch(url,{signal:controller.signal});if(!response.ok)throw new Error("Font request failed: "+response.status);const bytes=new Uint8Array(await response.arrayBuffer());let binary="";for(let i=0;i<bytes.length;i+=32768)binary+=String.fromCharCode(...bytes.subarray(i,i+32768));const mime=response.headers.get("content-type")?.split(";")[0]||"application/octet-stream";return"data:"+mime+";base64,"+btoa(binary)}finally{clearTimeout(timeout)}}export async function embedSvgFonts(markup,host){const doc=host?.ownerDocument;if(!doc||typeof DOMParser==="undefined")return markup;const svg=new DOMParser().parseFromString(markup,"image/svg+xml");if(svg.querySelector("parsererror"))return markup;const families=new Set;for(const element of Array.from(svg.querySelectorAll("[font-family],[style]"))){for(const family of svgFontFamilies(element.getAttribute("font-family")||element.style?.fontFamily||""))families.add(family)}if(!families.size)return markup;const sheets=[...Array.from(doc.styleSheets),...doc.adoptedStyleSheets??[]];let scope=host?.getRootNode();while(scope&&scope!==doc&&"host"in scope){const shadow=scope;sheets.push(...Array.from(shadow.styleSheets),...shadow.adoptedStyleSheets??[]);scope=shadow.host.getRootNode()}const loaded=[];doc.fonts?.forEach(face=>loaded.push(face));const rules=collectSvgFontRules(sheets,families,doc.fonts?loaded:void 0,doc.baseURI);if(!rules.length)return markup;const css=await inlineSvgFontRules(rules,fetchFontData);const style=svg.createElementNS("http://www.w3.org/2000/svg","style");style.setAttribute("data-chart-export-fonts","");style.textContent=css;svg.documentElement.insertBefore(style,svg.documentElement.firstChild);return new XMLSerializer().serializeToString(svg)}

package/dist/collection/components/chart/_shared/core/financial-bars.js

@@ -0,0 +1 @@
+export const FINANCIAL_SECONDS_THRESHOLD=1e11;export function resolveFinancialTime(raw){if(raw instanceof Date){const ms=raw.getTime();return Number.isFinite(ms)?ms:null}if(typeof raw==="number"){if(!Number.isFinite(raw))return null;return raw<FINANCIAL_SECONDS_THRESHOLD?Math.round(raw*1e3):Math.round(raw)}if(typeof raw==="string"&&raw.trim()!==""){const numeric=Number(raw);if(!Number.isNaN(numeric))return resolveFinancialTime(numeric);const parsed=Date.parse(raw);return Number.isNaN(parsed)?null:parsed}return null}export function resolveFinancialBars(input){if(!Array.isArray(input))return[];const byTime=new Map;for(const row of input){if(!row)continue;const isTuple=Array.isArray(row);const rawTime=isTuple?row[0]:row.time;const open=isTuple?row[1]:row.open;const high=isTuple?row[2]:row.high;const low=isTuple?row[3]:row.low;const close=isTuple?row[4]:row.close;const volume=isTuple?row[5]:row.volume;const time=resolveFinancialTime(rawTime);if(time===null)continue;if(![open,high,low,close].every(v=>typeof v==="number"&&Number.isFinite(v)))continue;const bodyHigh=Math.max(open,close);const bodyLow=Math.min(open,close);const bar={time,open,high:Math.max(high,bodyHigh),low:Math.min(low,bodyLow),close,...typeof volume==="number"&&Number.isFinite(volume)&&volume>=0?{volume}:{}};byTime.set(time,bar)}return[...byTime.values()].sort((a,b)=>a.time-b.time)}

package/dist/collection/components/chart/_shared/core/format/datetime.js

@@ -0,0 +1 @@
+export function format(specifier,locale){if(typeof specifier!=="string"){const intl=new Intl.DateTimeFormat(locale,specifier);return value=>{const date=coerceDate(value);if(date===null)return"Invalid Date";return intl.format(date)}}const spec=parseFormatSpec(specifier);const intlCache=new Map;return value=>formatWithSpec(value,spec,locale,intlCache)}export function formatDateTime(value,specifier="%Y-%m-%dT%H:%M:%S.%L",locale){return format(specifier,locale)(value)}export function parseFormatSpec(specifier){const tokens=[];let buffer="";const flushLiteral=()=>{if(buffer!==""){tokens.push({type:"literal",value:buffer});buffer=""}};let i=0;while(i<specifier.length){const ch=specifier[i];if(ch!=="%"){buffer+=ch;i++;continue}if(i+1>=specifier.length){buffer+="%";i++;continue}let j=i+1;let pad;const next=specifier[j];if(next==="-"){pad="none";j++}else if(next==="_"){pad=" ";j++}else if(next==="0"){pad="0";j++}if(j>=specifier.length){buffer+=specifier.slice(i,j);i=j;continue}const code=specifier[j];flushLiteral();const resolvedPad=pad!==void 0?pad:defaultPadFor(code);tokens.push({type:"directive",code,pad:resolvedPad});i=j+1}flushLiteral();return{tokens}}function defaultPadFor(code){return code==="e"?" ":"0"}function coerceDate(value){if(value instanceof Date){return Number.isNaN(value.getTime())?null:value}if(typeof value==="number"){if(!Number.isFinite(value))return null;const d=new Date(value);return Number.isNaN(d.getTime())?null:d}if(typeof value==="string"){const d=new Date(value);return Number.isNaN(d.getTime())?null:d}return null}function formatWithSpec(value,spec,locale,intlCache){const date=coerceDate(value);if(date===null)return"Invalid Date";let out="";for(const tok of spec.tokens){if(tok.type==="literal"){out+=tok.value;continue}out+=renderDirective(tok.code,tok.pad,date,locale,intlCache)}return out}function renderDirective(code,pad,date,locale,intlCache){if(code==="%")return"%";if(code==="n")return"\n";if(code==="t")return"	";switch(code){case"Y":return padNumber(date.getFullYear(),4,pad);case"y":return padNumber(date.getFullYear()%100,2,pad);case"m":return padNumber(date.getMonth()+1,2,pad);case"d":return padNumber(date.getDate(),2,pad);case"e":return padNumber(date.getDate(),2,pad);case"H":return padNumber(date.getHours(),2,pad);case"I":{const h12=date.getHours()%12;return padNumber(h12===0?12:h12,2,pad)}case"M":return padNumber(date.getMinutes(),2,pad);case"S":return padNumber(date.getSeconds(),2,pad);case"L":return padNumber(date.getMilliseconds(),3,pad);case"j":return padNumber(dayOfYear(date),3,pad);case"U":return padNumber(weekOfYearSunday(date),2,pad);case"W":return padNumber(weekOfYearMonday(date),2,pad)}const cacheKey=`${locale??""}::${code}`;let intl=intlCache.get(cacheKey);if(!intl){const opts=intlOptionsForDirective(code);if(opts===null){return"%"+code}intl=new Intl.DateTimeFormat(locale,opts);intlCache.set(cacheKey,intl)}if(code==="p"){return extractPart(intl,date,"dayPeriod")}if(code==="Z"){return extractPart(intl,date,"timeZoneName")}return intl.format(date)}function extractPart(intl,date,type){const parts=intl.formatToParts(date);for(const p of parts){if(p.type===type)return p.value}return""}function intlOptionsForDirective(code){switch(code){case"B":return{month:"long"};case"b":return{month:"short"};case"A":return{weekday:"long"};case"a":return{weekday:"short"};case"p":return{hour:"numeric",hour12:true,timeStyle:void 0};case"Z":return{timeZoneName:"short"};default:return null}}function padNumber(value,width,pad){const negative=value<0;const abs=Math.abs(value);let str=String(abs);if(pad==="none")return negative?"-"+str:str;const fillChar=pad===" "?" ":"0";const target=negative?width-1:width;if(str.length<target){str=fillChar.repeat(target-str.length)+str}return negative?"-"+str:str}function dayOfYear(date){const startOfYear=new Date(date.getFullYear(),0,1);const targetMidnight=new Date(date.getFullYear(),date.getMonth(),date.getDate());const ms=targetMidnight.getTime()-startOfYear.getTime();return Math.round(ms/864e5)+1}function weekOfYearSunday(date){const startOfYear=new Date(date.getFullYear(),0,1);const daysFromStart=daysSinceStartOfYear(date);const jan1Dow=startOfYear.getDay();const offsetToFirstSunday=(7-jan1Dow)%7;if(daysFromStart<offsetToFirstSunday)return 0;return Math.floor((daysFromStart-offsetToFirstSunday)/7)+1}function weekOfYearMonday(date){const startOfYear=new Date(date.getFullYear(),0,1);const daysFromStart=daysSinceStartOfYear(date);const jan1MonDow=(startOfYear.getDay()+6)%7;const offsetToFirstMonday=(7-jan1MonDow)%7;if(daysFromStart<offsetToFirstMonday)return 0;return Math.floor((daysFromStart-offsetToFirstMonday)/7)+1}function daysSinceStartOfYear(date){const startOfYear=new Date(date.getFullYear(),0,1);const targetMidnight=new Date(date.getFullYear(),date.getMonth(),date.getDate());const ms=targetMidnight.getTime()-startOfYear.getTime();return Math.round(ms/864e5)}

package/dist/collection/components/chart/_shared/core/format/duration.js

@@ -0,0 +1 @@
+export function formatDuration(ms,options={}){if(typeof ms!=="number"||Number.isNaN(ms)||!Number.isFinite(ms)){return"Invalid duration"}const style=options.style??"compact";const showZero=options.showZero??false;const smallest=options.smallest??"second";const largest=options.largest??"day";const requested=options.units??["hour","minute","second"];const active=filterAndSortUnits(requested,smallest,largest);if(active.length===0){const sign=ms<0?"-":"";return sign+Math.round(Math.abs(ms))+(style==="long"?" milliseconds":"ms")}const negative=ms<0;const absMs=Math.abs(ms);const smallestMs=MS_PER_UNIT[active[active.length-1]];const roundedMs=Math.round(absMs/smallestMs)*smallestMs;let remainder=roundedMs;const parts=[];for(let i=0;i<active.length;i++){const unit=active[i];const unitMs=MS_PER_UNIT[unit];const isLast=i===active.length-1;let count;if(isLast){count=Math.round(remainder/unitMs)}else{count=Math.floor(remainder/unitMs);remainder-=count*unitMs}parts.push({unit,count})}const visible=showZero?parts:trimEdgeZeros(parts);if(visible.length===0){const tail={unit:active[active.length-1],count:0};return renderParts([tail],style,options.locale,negative)}return renderParts(visible,style,options.locale,negative)}const UNIT_ORDER=["day","hour","minute","second","millisecond"];const MS_PER_UNIT={day:864e5,hour:36e5,minute:6e4,second:1e3,millisecond:1};const COMPACT_SUFFIX={day:"d",hour:"h",minute:"m",second:"s",millisecond:"ms"};const LONG_NAMES={day:{one:"day",other:"days"},hour:{one:"hour",other:"hours"},minute:{one:"minute",other:"minutes"},second:{one:"second",other:"seconds"},millisecond:{one:"millisecond",other:"milliseconds"}};function filterAndSortUnits(requested,smallest,largest){const requestedSet=new Set(requested);const smallestIdx=UNIT_ORDER.indexOf(smallest);const largestIdx=UNIT_ORDER.indexOf(largest);const lo=Math.min(largestIdx,smallestIdx);const hi=Math.max(largestIdx,smallestIdx);const out=[];for(let i=lo;i<=hi;i++){if(requestedSet.has(UNIT_ORDER[i])){out.push(UNIT_ORDER[i])}}return out}function trimEdgeZeros(parts){let lo=0;let hi=parts.length;while(lo<hi&&parts[lo].count===0)lo++;while(hi>lo&&parts[hi-1].count===0)hi--;return parts.slice(lo,hi)}function renderParts(parts,style,locale,negative){const sep=style==="long"?", ":" ";const pieces=parts.map(p=>style==="compact"?`${p.count}${COMPACT_SUFFIX[p.unit]}`:`${p.count} ${pluralName(p.unit,p.count,locale)}`);const joined=pieces.join(sep);return negative?"-"+joined:joined}function pluralName(unit,count,locale){const names=LONG_NAMES[unit];const magnitude=Math.abs(count);const effectiveLocale=locale??"en";if(typeof Intl!=="undefined"&&typeof Intl.PluralRules==="function"){const rules=new Intl.PluralRules(effectiveLocale);const cat=rules.select(magnitude);return cat==="one"?names.one:names.other}return magnitude===1?names.one:names.other}

package/dist/collection/components/chart/_shared/core/format/index.js

@@ -0,0 +1 @@
+export*from"./number.js";export{formatDateTime,parseFormatSpec as parseDateTimeFormatSpec}from"./datetime.js";export*from"./duration.js";

package/dist/collection/components/chart/_shared/core/format/number.js

@@ -0,0 +1 @@
+function clamp(value,min,max){if(Number.isNaN(value)||Number.isNaN(min)||Number.isNaN(max)){return NaN}if(min>max){const tmp=min;min=max;max=tmp}if(value<min)return min;if(value>max)return max;return value}const SPEC_RE=/^(?:([^{}])?([<>=^]))?([+\-( ])?([$#])?(0)?(\d+)?(,)?(?:\.(\d+))?(~)?([a-zA-Z%])?$/;export function parseFormatSpec(specifier){if(specifier==="")return{};const m=SPEC_RE.exec(specifier);if(!m){throw new SyntaxError(`Invalid number format specifier: "${specifier}"`)}const[,fill,align,sign,symbol,zero,width,comma,precision,trim,type]=m;const spec={};if(fill!==void 0)spec.fill=fill;if(align!==void 0)spec.align=align;if(sign!==void 0)spec.sign=sign;if(symbol!==void 0)spec.symbol=symbol;if(zero!==void 0)spec.zero=true;if(width!==void 0)spec.width=+width;if(comma!==void 0)spec.comma=true;if(precision!==void 0)spec.precision=+precision;if(trim!==void 0)spec.trim=true;if(type!==void 0&&type!==""){if(!isSupportedType(type)){throw new SyntaxError(`Invalid number format type: "${type}" in "${specifier}"`)}spec.type=type}return spec}function isSupportedType(t){return t==="f"||t==="e"||t==="g"||t==="s"||t==="r"||t==="%"||t==="p"||t==="d"||t==="n"||t==="b"||t==="o"||t==="x"||t==="X"||t==="c"}export function format(specifier,locale){const spec=typeof specifier==="string"?parseFormatSpec(specifier):{...specifier};let cachedIntl;return value=>formatWithSpec(value,spec,locale,()=>{if(cachedIntl)return cachedIntl;cachedIntl=makeIntlForSpec(spec,locale);return cachedIntl})}export function formatNumber(value,specifier="",locale){return format(specifier,locale)(value)}function formatWithSpec(value,spec,locale,getIntl){if(Number.isNaN(value)){return padResult("NaN","",spec,false)}if(!Number.isFinite(value)){const sign=value<0?"-":"";return padResult("Infinity",sign,spec,true)}const type=spec.type??"";if(type==="b"||type==="o"||type==="x"||type==="X"){return formatBaseType(value,type,spec)}if(type==="c"){return formatCharType(value,spec)}if(type==="s"){return formatSiType(value,spec,locale)}if(type==="r"){return formatRoundType(value,spec,locale)}if(type==="p"){return formatRoundedPercentType(value,spec,locale)}return formatGeneric(value,spec,getIntl())}function formatGeneric(value,spec,intl){const type=spec.type??"";const negative=value<0||Object.is(value,-0);let body=intl.format(Math.abs(value));if(type==="e"){body=normaliseScientific(body)}if(spec.trim||type==="")body=trimTrailingZeros(body);const prefix=spec.symbol==="$"?"$":"";return padResult(prefix+body,signString(spec,negative),spec,true)}function formatBaseType(value,type,spec){const rounded=Math.round(value);const negative=rounded<0||Object.is(value,-0);const abs=Math.abs(rounded);let body;switch(type){case"b":body=abs.toString(2);break;case"o":body=abs.toString(8);break;case"x":body=abs.toString(16);break;case"X":body=abs.toString(16).toUpperCase();break}let prefix="";if(spec.symbol==="#"){if(type==="x")prefix="0x";else if(type==="X")prefix="0X";else if(type==="b")prefix="0b";else if(type==="o")prefix="0o"}return padResult(prefix+body,signString(spec,negative),spec,true)}function formatCharType(value,spec){const cp=Math.trunc(value);const ch=String.fromCodePoint(cp);return padResult(ch,"",spec,false)}const SI_PREFIXES=["y","z","a","f","p","n","µ","m","","k","M","G","T","P","E","Z","Y"];function formatSiType(value,spec,locale){const negative=value<0||Object.is(value,-0);const abs=Math.abs(value);if(abs===0){const precision2=clamp(spec.precision??6,1,20);const decimals2=Math.max(0,precision2-1);const body2=formatFixedPlain(0,decimals2,locale,spec.comma??false);const trimmed=spec.trim?trimTrailingZeros(body2):body2;return padResult(trimmed,signString(spec,false),spec,true)}const rawExp=Math.floor(Math.log10(abs)/3);const exp=clamp(rawExp,-8,8);const suffix=SI_PREFIXES[exp+8];const scaled=abs/Math.pow(10,exp*3);const precision=clamp(spec.precision??6,0,20);let decimals;if(scaled===0){decimals=Math.max(0,precision-1)}else{const magnitude=Math.floor(Math.log10(Math.abs(scaled)));decimals=Math.max(0,precision-1-magnitude)}let body=formatFixedPlain(scaled,decimals,locale,spec.comma??false);if(spec.trim)body=trimTrailingZeros(body);return padResult(body+suffix,signString(spec,negative),spec,true)}function formatRoundType(value,spec,locale){const negative=value<0||Object.is(value,-0);const abs=Math.abs(value);const precision=clamp(spec.precision??6,1,20);let body=formatRoundedPlain(abs,precision,locale,spec.comma??false);if(spec.trim)body=trimTrailingZeros(body);return padResult(body,signString(spec,negative),spec,true)}function formatRoundedPercentType(value,spec,locale){const negative=value<0||Object.is(value,-0);const absPercent=Math.abs(value)*100;const precision=clamp(spec.precision??6,1,20);let body=formatRoundedPlain(absPercent,precision,locale,spec.comma??false);if(spec.trim)body=trimTrailingZeros(body);return padResult(body+"%",signString(spec,negative),spec,true)}function formatRoundedPlain(abs,precision,locale,comma){if(abs===0){return formatFixedPlain(0,Math.max(0,precision-1),locale,comma)}const magnitude=Math.floor(Math.log10(abs));const factor=Math.pow(10,precision-1-magnitude);const rounded=Math.round(abs*factor)/factor;const decimals=Math.max(0,precision-1-magnitude);return formatFixedPlain(rounded,decimals,locale,comma)}function makeIntlForSpec(spec,locale){const type=spec.type??"";const opts={useGrouping:spec.comma||type==="n"?true:false};const precision=spec.precision;if(type==="d"){opts.maximumFractionDigits=0;opts.minimumFractionDigits=0}else if(type==="%"){opts.style="percent";const p=precision??6;opts.minimumFractionDigits=p;opts.maximumFractionDigits=p}else if(type==="e"){opts.notation="scientific";const p=precision??6;opts.minimumFractionDigits=p;opts.maximumFractionDigits=p}else if(type==="f"){const p=precision??6;opts.minimumFractionDigits=p;opts.maximumFractionDigits=p}else if(type==="g"||type==="n"||type===""){const p=clamp(precision??(type===""?12:6),1,21);opts.minimumSignificantDigits=p;opts.maximumSignificantDigits=p}return new Intl.NumberFormat(locale,opts)}function formatFixedPlain(value,decimals,locale,comma){const opts={minimumFractionDigits:decimals,maximumFractionDigits:decimals,useGrouping:!!comma};return new Intl.NumberFormat(locale,opts).format(value)}function signString(spec,negative){const sign=spec.sign??"-";if(negative){return sign==="("?"(":"-"}if(sign==="+")return"+";if(sign===" ")return" ";return""}function padResult(body,signPrefix,spec,signed){const suffix=signed&&signPrefix==="("?")":"";const fullBody=signPrefix+body+suffix;const width=spec.width??0;const fill=spec.fill??(spec.zero?"0":" ");let align=spec.align;if(align===void 0){align=spec.zero?"=":">"}if(width<=fullBody.length)return fullBody;const padCount=width-fullBody.length;const pad=fill.repeat(padCount);switch(align){case"<":return fullBody+pad;case"^":{const left=pad.slice(0,Math.floor(padCount/2));const right=pad.slice(left.length);return left+fullBody+right}case"=":if(signed){return signPrefix+pad+body+suffix}return pad+fullBody;case">":default:return pad+fullBody}}function trimTrailingZeros(s){const eIdx=s.search(/[eE]/);if(eIdx>=0){const head=s.slice(0,eIdx);const tail=s.slice(eIdx);return trimMantissa(head)+tail}return trimMantissa(s)}function normaliseScientific(s){return s.replace(/E(-?)(\d+)/,(_,neg,digits)=>{return"e"+(neg==="-"?"-":"+")+digits})}function trimMantissa(s){const m=/(.*?)([.,])(\d*?)0+$/.exec(s);if(!m)return s;const[,head,sep,frac]=m;if(frac===""){return head}return head+sep+frac}

package/dist/collection/components/chart/_shared/core/format/safe-formatter.js

@@ -0,0 +1 @@
+const warned=new WeakSet;export function reportChartFormatterError(formatter,error,label){if(warned.has(formatter))return;warned.add(formatter);console.warn(`[Syidax] ${label} failed; using the default chart content.`,error)}export function safeChartFormatter(formatter,args,fallback,label,receiver){if(formatter){try{return formatter.apply(receiver,args)}catch(error){reportChartFormatterError(formatter,error,label)}}return fallback()}

package/dist/collection/components/chart/_shared/core/graph/strongly-connected.js

@@ -0,0 +1 @@
+export function stronglyConnectedComponents(outgoing,reverse){const count=outgoing.length,incoming=reverse??(()=>{const result=Array.from({length:count},()=>[]);for(let source=0;source<count;source++)for(const target of outgoing[source])result[target].push(source);return result})();const visited=new Uint8Array(count),finished=[],stack=[],cursor=[];for(let start=0;start<count;start++){if(visited[start])continue;visited[start]=1;stack.push(start);cursor.push(0);while(stack.length){const top=stack.length-1,node=stack[top],offset=cursor[top];if(offset===outgoing[node].length){finished.push(node);stack.pop();cursor.pop();continue}const next=outgoing[node][offset];cursor[top]++;if(!visited[next]){visited[next]=1;stack.push(next);cursor.push(0)}}}visited.fill(0);const members=[];for(let order=finished.length-1;order>=0;order--){const start=finished[order];if(visited[start])continue;const group=[];visited[start]=1;stack.push(start);while(stack.length){const node=stack.pop();group.push(node);for(const next of incoming[node])if(!visited[next]){visited[next]=1;stack.push(next)}}members.push(group.sort((a,b)=>a-b))}return members.sort((a,b)=>a[0]-b[0])}

package/dist/collection/components/chart/_shared/core/hover/highlight.js

@@ -0,0 +1 @@
+function coerceMode(value){if(value==="series"||value==="point"||value==="series-and-point"||value==="none"){return{mode:value,warned:false}}return{mode:"none",warned:true}}function coerceDimOpacity(value){if(value===void 0)return .3;if(typeof value!=="number"||!Number.isFinite(value))return .3;if(value<0)return 0;if(value>1)return 1;return value}function coerceEmphasizeBoost(value){if(value===void 0)return{boost:1.5,warned:false};if(typeof value!=="number"||!Number.isFinite(value)){return{boost:1,warned:true}}if(value<1)return{boost:1,warned:false};return{boost:value,warned:false}}function findOverlap(disabled,locked){if(disabled===void 0||locked===void 0)return[];if(disabled.size===0||locked.size===0)return[];const out=[];for(const id of disabled){if(locked.has(id))out.push(id)}return out}function catalogContains(catalog,target){for(let i=0;i<catalog.length;i++){if(catalog[i].id===target)return true}return false}function pointIdsContains(pointIds,target){if(pointIds===void 0||pointIds.length===0)return false;for(let i=0;i<pointIds.length;i++){if(pointIds[i]===target)return true}return false}function formatOverlapIds(ids){if(ids.length<=8)return ids.map(String).join(", ");const head=ids.slice(0,8).map(String).join(", ");return head+", … and "+String(ids.length-8)+" more"}export function computeHoverHighlight(input){const modeResult=coerceMode(input.mode);const mode=modeResult.mode;if(modeResult.warned){console.warn('[Syidax] sy-chart hover-highlight: invalid mode "'+String(input.mode)+'"; coerced to "none".')}const dimOpacity=coerceDimOpacity(input.dimOpacity);const boostResult=coerceEmphasizeBoost(input.emphasizeBoost);const emphasizeBoost=boostResult.boost;if(boostResult.warned){console.warn("[Syidax] sy-chart hover-highlight: emphasizeBoost is non-finite ("+String(input.emphasizeBoost)+"); coerced to 1 (no boost).")}const disabledIds=input.disabledIds;let effectiveLocked=input.lockedIds;const overlap=findOverlap(disabledIds,input.lockedIds);if(overlap.length>0){console.warn("[Syidax] sy-chart hover-highlight: "+String(overlap.length)+" id(s) appear in both disabledIds and lockedIds; treating as disabled. Affected: "+formatOverlapIds(overlap)+".");const next=new Set;if(input.lockedIds!==void 0){for(const id of input.lockedIds){if(disabledIds===void 0||!disabledIds.has(id)){next.add(id)}}}effectiveLocked=next}const catalog=input.seriesCatalog??[];if(catalog.length===0){return{series:new Map,pointEmphasized:null,meta:{mode,locked:0,disabled:0}}}let hoveredSeriesId=null;let hoveredPointId=void 0;if(input.hovered!==null&&input.hovered!==void 0){if(catalogContains(catalog,input.hovered.seriesId)){hoveredSeriesId=input.hovered.seriesId;hoveredPointId=input.hovered.pointId}else{console.warn('[Syidax] sy-chart hover-highlight: hovered.seriesId "'+String(input.hovered.seriesId)+'" not in seriesCatalog; treating as no hover.')}}const seriesMap=new Map;let lockedCount=0;let disabledCount=0;for(let i=0;i<catalog.length;i++){const entry=catalog[i];const id=entry.id;if(seriesMap.has(id))continue;if(disabledIds!==void 0&&disabledIds.has(id)){seriesMap.set(id,{opacity:0,emphasis:1,disabled:true,locked:false});disabledCount++;continue}const isHovered=hoveredSeriesId!==null&&id===hoveredSeriesId;const isLocked=effectiveLocked!==void 0&&effectiveLocked.has(id);if(isHovered){seriesMap.set(id,{opacity:1,emphasis:emphasizeBoost,disabled:false,locked:isLocked});if(isLocked)lockedCount++;continue}if(isLocked){seriesMap.set(id,{opacity:1,emphasis:1,disabled:false,locked:true});lockedCount++;continue}let opacity=1;if(hoveredSeriesId!==null){if(mode==="series"||mode==="series-and-point"){opacity=dimOpacity}}seriesMap.set(id,{opacity,emphasis:1,disabled:false,locked:false})}let pointEmphasized=null;if((mode==="point"||mode==="series-and-point")&&hoveredSeriesId!==null&&hoveredPointId!==void 0){const hoveredDisabled=disabledIds!==void 0&&disabledIds.has(hoveredSeriesId);if(!hoveredDisabled){let entry=void 0;for(let i=0;i<catalog.length;i++){if(catalog[i].id===hoveredSeriesId){entry=catalog[i];break}}if(entry!==void 0&&pointIdsContains(entry.pointIds,hoveredPointId)){pointEmphasized={seriesId:hoveredSeriesId,pointId:hoveredPointId}}}}return{series:seriesMap,pointEmphasized,meta:{mode,locked:lockedCount,disabled:disabledCount}}}

package/dist/collection/components/chart/_shared/core/hover/index.js

@@ -0,0 +1 @@
+export{computeHoverHighlight}from"./highlight.js";

package/dist/collection/components/chart/_shared/core/index.js

@@ -0,0 +1 @@
+export*from"./types.js";export*from"./math/index.js";export*from"./animation/index.js";export*from"./color/index.js";export*from"./format/index.js";export*from"./axis/index.js";export*from"./layout/index.js";export*from"./event/index.js";export*from"./spatial/index.js";export*from"./tooltip/index.js";export*from"./crosshair/index.js";export*from"./hover/index.js";export*from"./stream/index.js";export*from"./adapter/index.js";export*from"./contract/index.js";export*from"./data/index.js";

package/dist/collection/components/chart/_shared/core/layout/axis-label-thinning.js

@@ -0,0 +1 @@
+const DEFAULT_CHAR_WIDTH_FACTOR=.6;export function thinAxisTicks(ticks,opts){if(ticks.length<=2)return ticks;if(!Number.isFinite(opts.plotSize)||opts.plotSize<=0)return ticks;if(opts.measureText&&opts.orientation==="horizontal"&&ticks.length>256){const candidates=thinAxisTicks(ticks,{...opts,measureText:void 0});if(candidates.length<ticks.length)return thinAxisTicks(candidates,opts)}const fontSize=opts.fontSize??11;const minPadding=opts.minPadding??6;const format=opts.format??defaultFormat;let maxLen=0;let maxWidth=0;for(const t of ticks){const text=format(t);if(text.length>maxLen)maxLen=text.length;const measured=text&&opts.orientation==="horizontal"?opts.measureText?.(text,fontSize):void 0;const width=measured!==void 0&&Number.isFinite(measured)&&measured>=0?measured:text.length*fontSize*DEFAULT_CHAR_WIDTH_FACTOR;maxWidth=Math.max(maxWidth,width)}if(maxLen===0)return ticks;const requiredSpacing=opts.orientation==="horizontal"?maxWidth+minPadding:fontSize*1.35+minPadding;const first=ticks[0].position;const last=ticks[ticks.length-1].position;const span=Math.abs(last-first);if(span<=0)return ticks;const avgGap=span/(ticks.length-1);if(avgGap>=requiredSpacing)return ticks;const step=Math.max(1,Math.ceil(requiredSpacing/avgGap));if(step<=1)return ticks;const out=[];for(let i=0;i<ticks.length;i++){if(i%step===0)out.push(ticks[i])}const lastTick=ticks[ticks.length-1];if(out[out.length-1]!==lastTick){const survivorBeforeEnd=out[out.length-1];if(survivorBeforeEnd&&Math.abs(lastTick.position-survivorBeforeEnd.position)<requiredSpacing){out[out.length-1]=lastTick}else{out.push(lastTick)}}return out}function defaultFormat(tick){return tick.label??(Number.isInteger(tick.value)?`${tick.value}`:tick.value.toFixed(2))}export function thinGridLines(lines,axis,plotSize,minSpacing=8){if(lines.length<=2)return lines;if(!Number.isFinite(plotSize)||plotSize<=0)return lines;const pos=line=>(axis==="x"?line.x:line.y)??0;const span=Math.abs(pos(lines[lines.length-1])-pos(lines[0]));if(span<=0)return lines;const avgGap=span/(lines.length-1);if(avgGap>=minSpacing)return lines;const step=Math.max(1,Math.ceil(minSpacing/avgGap));if(step<=1)return lines;const out=[];for(let i=0;i<lines.length;i+=1){if(i%step===0)out.push(lines[i])}const lastLine=lines[lines.length-1];if(out[out.length-1]!==lastLine){const survivor=out[out.length-1];if(survivor&&Math.abs(pos(lastLine)-pos(survivor))<minSpacing){out[out.length-1]=lastLine}else{out.push(lastLine)}}return out}

package/dist/collection/components/chart/_shared/core/layout/cartesian-frame-interaction.js

@@ -0,0 +1 @@
+export function cartesianHitTest(input){if(input.points.length===0)return null;let best=-1;let bestDist=Number.POSITIVE_INFINITY;for(let i=0;i<input.points.length;i++){const p=input.points[i];const dx=p.cssX-input.cssX;const dy=p.cssY-input.cssY;const dist=dx*dx+dy*dy;if(dist<bestDist){bestDist=dist;best=i}}const hit=input.points[best];return{pointIndex:hit.index,cssX:hit.cssX,cssY:hit.cssY,value:hit.value,distance:Math.sqrt(bestDist)}}export function cartesianCrosshairGeometry(input){const{plot}=input.frame;const clampedX=Math.min(plot.x+plot.width,Math.max(plot.x,input.cssX));const clampedY=Math.min(plot.y+plot.height,Math.max(plot.y,input.cssY));let snappedX=clampedX;let snappedY=clampedY;let snappedIndex;if(input.spec.snap!=="off"&&input.points&&input.points.length>0){const snapTarget=input.spec.snap;let best=-1;let bestDist=Number.POSITIVE_INFINITY;for(let i=0;i<input.points.length;i++){const p=input.points[i];const dx=p.cssX-clampedX;const dy=p.cssY-clampedY;const dist=snapTarget==="index"?Math.abs(dx):Math.sqrt(dx*dx+dy*dy);if(dist<bestDist){bestDist=dist;best=i}}if(best>=0){snappedX=input.points[best].cssX;snappedY=input.points[best].cssY;snappedIndex=input.points[best].index}}const result={plotX:plot.x,plotY:plot.y,plotWidth:plot.width,plotHeight:plot.height,snappedPointIndex:snappedIndex};if(input.spec.mode==="vertical"||input.spec.mode==="cross"){result.verticalX=snappedX}if(input.spec.mode==="horizontal"||input.spec.mode==="cross"){result.horizontalY=snappedY}return result}export function cartesianTooltipAnchor(input){const{plot}=input.frame;const{cssX,cssY}=input.hit;const room={top:cssY-plot.y,right:plot.x+plot.width-cssX,bottom:plot.y+plot.height-cssY,left:cssX-plot.x};const preferred=input.spec.side;let side;if(preferred&&room[preferred]>=0){side=preferred}else{let best="top";for(const s of["top","right","bottom","left"]){if(room[s]>room[best])best=s}side=best}return{cssX,cssY,side}}

package/dist/collection/components/chart/_shared/core/layout/cartesian-frame.js

@@ -0,0 +1 @@
+import{clampZoomWindow}from"../zoom/zoom-window.js";import{safeChartFormatter}from"../format/safe-formatter.js";function makeLinear(domainStart,domainEnd,rangeStart,rangeEnd){const scale=(value=>{if(domainStart===domainEnd)return(rangeStart+rangeEnd)/2;const t=(value-domainStart)/(domainEnd-domainStart);return rangeStart+t*(rangeEnd-rangeStart)});scale.invert=value=>{if(rangeStart===rangeEnd)return domainStart;const t=(value-rangeStart)/(rangeEnd-rangeStart);return domainStart+t*(domainEnd-domainStart)};scale.ticks=(count=5)=>{if(count<=0)return[];const lo=Math.min(domainStart,domainEnd);const hi=Math.max(domainStart,domainEnd);if(lo===hi)return[lo];const span=hi-lo;const rawStep=span/count;const mag=Math.pow(10,Math.floor(Math.log10(rawStep)));const normalized=rawStep/mag;const step=(normalized>=5?5:normalized>=2?2:1)*mag;const start=Math.ceil(lo/step)*step;const out=[];for(let v=start;v<=hi+step*1e-6;v+=step){out.push(Math.round(v/step)*step)}return out};scale.domain=()=>[domainStart,domainEnd];scale.range=()=>[rangeStart,rangeEnd];return scale}function logBase(value,base){if(base===10)return Math.log10(value);if(base===2)return Math.log2(value);return Math.log(value)/Math.log(base)}function cleanLogTick(value){if(!Number.isFinite(value))return value;const nearest=Math.round(value);if(Math.abs(value-nearest)<=Math.max(1,Math.abs(value))*1e-12){return Object.is(nearest,-0)?0:nearest}const rounded=Number(value.toPrecision(15));return Object.is(rounded,-0)?0:rounded}function makeLog(domainStart,domainEnd,rangeStart,rangeEnd,base=10){const sameSign=domainStart!==0&&domainEnd!==0&&domainStart*domainEnd>0;if(!sameSign||!Number.isFinite(domainStart)||!Number.isFinite(domainEnd)){return makeLinear(domainStart,domainEnd,rangeStart,rangeEnd)}const sign=domainStart>0?1:-1;const scale=(value=>{if(sign===1&&value<=0||sign===-1&&value>=0)return NaN;const d0=sign*domainStart;const d1=sign*domainEnd;const v=sign*value;const ld0=logBase(d0,base);const ld1=logBase(d1,base);if(ld0===ld1)return(rangeStart+rangeEnd)/2;const t=(logBase(v,base)-ld0)/(ld1-ld0);return rangeStart+t*(rangeEnd-rangeStart)});scale.invert=value=>{const d0=sign*domainStart;const d1=sign*domainEnd;const ld0=logBase(d0,base);const ld1=logBase(d1,base);if(rangeStart===rangeEnd)return domainStart;const t=(value-rangeStart)/(rangeEnd-rangeStart);return sign*Math.pow(base,ld0+t*(ld1-ld0))};scale.ticks=(count=5)=>{const d0=sign*domainStart;const d1=sign*domainEnd;const lo=Math.min(d0,d1);const hi=Math.max(d0,d1);if(lo<=0||!Number.isFinite(lo)||!Number.isFinite(hi))return[];const i0=Math.ceil(logBase(lo,base)-1e-12);const i1=Math.floor(logBase(hi,base)+1e-12);const raw=[];for(let i=i0;i<=i1;i++){const v=cleanLogTick(Math.pow(base,i));if(v>=lo*(1-1e-12)&&v<=hi*(1+1e-12))raw.push(sign*v)}const n=Math.max(0,Math.floor(count));if(n>0&&raw.length>n){const out=[];const last=raw.length-1;for(let i=0;i<n;i++)out.push(raw[Math.round(i*last/Math.max(1,n-1))]);return domainEnd<domainStart?out.reverse():out}return domainEnd<domainStart?raw.reverse():raw};scale.domain=()=>[domainStart,domainEnd];scale.range=()=>[rangeStart,rangeEnd];return scale}const AXIS_LABEL_W=48;const AXIS_LABEL_H=42;const Y_AXIS_TITLE_W=24;const TITLE_H=28;const SUBTITLE_H=18;const COLLAPSED_GUTTER=4;const REQUIRED_TICK_MIN_GAP_PX=34;const TICK_VALUE_EPSILON=1e-9;function effectiveExtent(extent,min,max){const lo=Number.isFinite(min)?min:extent.min;const hi=Number.isFinite(max)?max:extent.max;if(lo===hi){return{min:lo-1,max:lo+1}}return lo<hi?{min:lo,max:hi}:{min:hi,max:lo}}function categoryTicks(min,max,count){const lo=Math.ceil(min);const hi=Math.floor(max);if(hi<lo)return[];const all=[];for(let v=lo;v<=hi;v++)all.push(v);const n=Math.max(0,Math.floor(count));if(n===0||all.length<=n)return all;if(n===1)return[all[0]];const out=[];const last=all.length-1;for(let i=0;i<n;i++)out.push(all[Math.round(i*last/(n-1))]);return out}function defaultTickLabel(axis,value){if(axis.format)return safeChartFormatter(axis.format,[value],()=>defaultTickLabel({...axis,format:void 0},value),"axis.format",axis);if(axis.kind==="time"){const d=new Date(value);if(!Number.isFinite(+d))return String(value);return d.toISOString().slice(0,10)}if(axis.kind==="log"){const abs=Math.abs(value);if(abs>=1e4||abs>0&&abs<.001)return value.toExponential(0)}if(axis.kind==="category"){const index=Math.round(value);return axis.categories?.[index]??String(index)}return Number.isInteger(value)?String(value):value.toFixed(2)}function makeScaleForAxis(axis,extent,rangeStart,rangeEnd){if(axis.kind==="log"){return makeLog(extent.min,extent.max,rangeStart,rangeEnd)}return makeLinear(extent.min,extent.max,rangeStart,rangeEnd)}function ticksForAxis(axis,scale,count){const domain=scale.domain();const values=axis.kind==="category"?categoryTicks(domain[0],domain[1],count):scale.ticks(count);return values.map(value=>({value,position:scale(value),label:defaultTickLabel(axis,value)}))}function normalizeRequiredTickValues(value){const values=Array.isArray(value)?value:value===void 0?[]:[value];return values.filter(entry=>Number.isFinite(entry))}function sameTickValue(a,b){if(!Number.isFinite(a)||!Number.isFinite(b))return false;const scale=Math.max(1,Math.abs(a),Math.abs(b));return Math.abs(a-b)<=scale*TICK_VALUE_EPSILON}function clampToRange(value,a,b){const lo=Math.min(a,b);const hi=Math.max(a,b);return Math.min(Math.max(value,lo),hi)}function withRequiredTicks(axis,scale,ticks,requiredValues,rangeStart,rangeEnd,minPixelGap){const[domainStart,domainEnd]=scale.domain();const domainLo=Math.min(domainStart,domainEnd);const domainHi=Math.max(domainStart,domainEnd);const domainTolerance=Math.max(1,Math.abs(domainLo),Math.abs(domainHi))*TICK_VALUE_EPSILON;const required=requiredValues.filter(value=>value>=domainLo-domainTolerance&&value<=domainHi+domainTolerance).map(value=>{const rawPosition=scale(value);if(!Number.isFinite(rawPosition))return null;return{value,position:clampToRange(rawPosition,rangeStart,rangeEnd),label:defaultTickLabel(axis,value)}}).filter(entry=>entry!==null);if(required.length===0)return[...ticks];const kept=ticks.filter(tick=>{if(required.some(entry=>sameTickValue(entry.value,tick.value)))return true;return required.every(entry=>Math.abs(tick.position-entry.position)>=minPixelGap)});const result=[...kept];for(const entry of required){if(!result.some(tick=>sameTickValue(tick.value,entry.value)))result.push(entry)}return result.sort((a,b)=>a.value-b.value||a.position-b.position)}function shouldIncludeGridLine(value,requiredValues,includeRequiredGridLines){return includeRequiredGridLines||!requiredValues.some(required=>sameTickValue(required,value))}function clampPositive(value){return Number.isFinite(value)&&value>0?value:0}function cartesianFrameAxisKey(axis,fallbackIndex){return String(axis?.id??fallbackIndex)}function cartesianFrameAxisExtent(extents,axis,index){if(!extents)return void 0;return extents[cartesianFrameAxisKey(axis,index)]??extents[String(index)]}function yAxisGutterFor(axis){return AXIS_LABEL_W+(axis.label?Y_AXIS_TITLE_W:0)}function sideYAxesGutter(axes){const visible=axes.filter(axis=>axis.show);if(visible.length===0)return COLLAPSED_GUTTER;return visible.reduce((sum,axis)=>sum+yAxisGutterFor(axis),0)}function yAxisSideOf(axis){return axis.position==="right"?"right":"left"}function layoutYAxisSides(yAxes){const consumed={left:0,right:0};return yAxes.map(axis=>{const side=yAxisSideOf(axis);const gutter=axis.show?yAxisGutterFor(axis):0;const offset=consumed[side];consumed[side]+=gutter;return{side,offset,gutter}})}function xAxisSideOf(axis){return axis.position==="top"?"top":"bottom"}function sideXAxesGutter(axes){const visible=axes.filter(axis=>axis.show);if(visible.length===0)return COLLAPSED_GUTTER;return visible.length*AXIS_LABEL_H}function layoutXAxisSides(xAxes){const consumed={top:0,bottom:0};return xAxes.map(axis=>{const side=xAxisSideOf(axis);const gutter=axis.show?AXIS_LABEL_H:0;const offset=consumed[side];consumed[side]+=gutter;return{side,offset,gutter}})}function resolveAxisMasters(axes){const keys=axes.map((axis,index)=>cartesianFrameAxisKey(axis,index));const directTarget=index=>{const target=axes[index].linkedTo;if(target===void 0||target===null)return-1;let found=keys.indexOf(String(target));if(found<0&&typeof target==="number"&&Number.isInteger(target)&&target>=0&&target<axes.length){found=target}return found===index?-1:found};return axes.map((_,index)=>{const visited=new Set([index]);let current=index;let next=directTarget(current);while(next>=0){if(visited.has(next))return-1;visited.add(next);current=next;next=directTarget(current)}return current===index?-1:current})}function unionExtent(a,b){if(!a)return b;if(!b)return a;return{min:Math.min(a.min,b.min),max:Math.max(a.max,b.max)}}function resolveAxisExtents(axes,masters,extents,fallback,windows){const resolved=new Array(axes.length);const full=new Array(axes.length);axes.forEach((axis,index)=>{if(masters[index]>=0)return;let source=cartesianFrameAxisExtent(extents,axis,index);masters.forEach((master,child)=>{if(master===index)source=unionExtent(source,cartesianFrameAxisExtent(extents,axes[child],child))});const base=effectiveExtent(source??fallback,axis.min,axis.max);full[index]=base;const window=windows?windows[cartesianFrameAxisKey(axis,index)]??windows[String(index)]:void 0;resolved[index]=window&&window.max>window.min?clampZoomWindow(window,base):base});axes.forEach((_,index)=>{if(masters[index]>=0)resolved[index]=resolved[masters[index]];if(masters[index]>=0)full[index]=full[masters[index]]});return{resolved,full}}export function computeCartesianFrame(input){const outerWidth=clampPositive(input.outerWidth);const outerHeight=clampPositive(input.outerHeight);const xAxes=input.axes.xAxes?.length?input.axes.xAxes:[input.axes.x];const yAxes=input.axes.yAxes?.length?input.axes.yAxes:[input.axes.y];const hasTitle=typeof input.title==="string"&&input.title.trim().length>0;const hasSubtitle=typeof input.subtitle==="string"&&input.subtitle.trim().length>0;const titleStripH=(hasTitle?TITLE_H:0)+(hasSubtitle?SUBTITLE_H:0);const leftGutter=sideYAxesGutter(yAxes.filter(axis=>axis.position!=="right"));const rightGutter=sideYAxesGutter(yAxes.filter(axis=>axis.position==="right"));const topGutter=sideXAxesGutter(xAxes.filter(axis=>axis.position==="top"))+titleStripH;const bottomGutter=sideXAxesGutter(xAxes.filter(axis=>axis.position!=="top"));const margins={top:topGutter,right:rightGutter,bottom:bottomGutter,left:leftGutter};const plotWidth=Math.max(0,outerWidth-margins.left-margins.right);const plotHeight=Math.max(0,outerHeight-margins.top-margins.bottom);const plot={x:margins.left,y:margins.top,width:plotWidth,height:plotHeight};const fallbackTickCount=Number.isFinite(input.tickCount)&&input.tickCount>0?Math.floor(input.tickCount):5;const primaryXAxisIndex=Math.max(0,xAxes.findIndex(axis=>axis.show));const primaryYAxisIndex=Math.max(0,yAxes.findIndex(axis=>axis.show));const requiredXValues=normalizeRequiredTickValues(input.requiredTicks?.x);const requiredYValues=normalizeRequiredTickValues(input.requiredTicks?.y);const requiredTickGap=Number.isFinite(input.requiredTicks?.minPixelGap)?Math.max(0,input.requiredTicks?.minPixelGap):REQUIRED_TICK_MIN_GAP_PX;const includeRequiredGridLines=input.requiredTicks?.includeGridLines!==false;const xSideLayout=layoutXAxisSides(xAxes);const xMasters=resolveAxisMasters(xAxes);const xResolvedExtents=resolveAxisExtents(xAxes,xMasters,input.xExtents,input.xExtent,input.zoom?.x);const xScaleAxes=xAxes.map((axis,index)=>xMasters[index]>=0?{...axis,kind:xAxes[xMasters[index]].kind,reversed:xAxes[xMasters[index]].reversed}:axis);const xScaleByIndex=xAxes.map((_,index)=>xScaleAxes[index].reversed?makeScaleForAxis(xScaleAxes[index],xResolvedExtents.resolved[index],plot.x+plot.width,plot.x):makeScaleForAxis(xScaleAxes[index],xResolvedExtents.resolved[index],plot.x,plot.x+plot.width));const xTickCache=new Map;const xRawTicksFor=index=>{const cached=xTickCache.get(index);if(cached)return cached;const masterIndex=xMasters[index];const scaleAxis=xScaleAxes[index];const ticks=masterIndex>=0?xRawTicksFor(masterIndex).map(tick=>({value:tick.value,position:tick.position,label:defaultTickLabel(scaleAxis,tick.value)})):withRequiredTicks(scaleAxis,xScaleByIndex[index],ticksForAxis(scaleAxis,xScaleByIndex[index],xAxes[index].tickCount??fallbackTickCount),index===primaryXAxisIndex?requiredXValues:[],plot.x,plot.x+plot.width,requiredTickGap);xTickCache.set(index,ticks);return ticks};const xAxisFrames=xAxes.map((axis,index)=>{const key=cartesianFrameAxisKey(axis,index);const{side,offset,gutter}=xSideLayout[index];const linePosition=side==="top"?plot.y-offset:plot.y+plot.height+offset;const masterIndex=xMasters[index];const scale=xScaleByIndex[index];const requiredValues=index===primaryXAxisIndex?requiredXValues:[];const ticks=axis.show?xRawTicksFor(index):[];const gridLines=index===primaryXAxisIndex&&input.gridLines.x?ticks.filter(t=>shouldIncludeGridLine(t.value,requiredValues,includeRequiredGridLines)).map(t=>({x:t.position,value:t.value})):[];const fullExtent=xResolvedExtents.full[index];const frame={key,axis,scale,ticks,gridLines,side,offset,gutter,linePosition,fullExtent};if(masterIndex>=0)frame.linkedTo=cartesianFrameAxisKey(xAxes[masterIndex],masterIndex);return frame});const primaryX=xAxisFrames[primaryXAxisIndex]??xAxisFrames[0];const xScale=primaryX.scale;const xTicks=primaryX.ticks;const sideLayout=layoutYAxisSides(yAxes);const yMasters=resolveAxisMasters(yAxes);const yResolvedExtents=resolveAxisExtents(yAxes,yMasters,input.yExtents,input.yExtent,input.zoom?.y);const yScaleAxes=yAxes.map((axis,index)=>yMasters[index]>=0?{...axis,kind:yAxes[yMasters[index]].kind,reversed:yAxes[yMasters[index]].reversed}:axis);const yScaleByIndex=yAxes.map((_,index)=>yScaleAxes[index].reversed?makeScaleForAxis(yScaleAxes[index],yResolvedExtents.resolved[index],plot.y,plot.y+plot.height):makeScaleForAxis(yScaleAxes[index],yResolvedExtents.resolved[index],plot.y+plot.height,plot.y));const yTickCache=new Map;const yRawTicksFor=index=>{const cached=yTickCache.get(index);if(cached)return cached;const masterIndex=yMasters[index];const scaleAxis=yScaleAxes[index];const ticks=masterIndex>=0?yRawTicksFor(masterIndex).map(tick=>({value:tick.value,position:tick.position,label:defaultTickLabel(scaleAxis,tick.value)})):withRequiredTicks(scaleAxis,yScaleByIndex[index],ticksForAxis(scaleAxis,yScaleByIndex[index],yAxes[index].tickCount??fallbackTickCount),index===primaryYAxisIndex?requiredYValues:[],plot.y,plot.y+plot.height,requiredTickGap);yTickCache.set(index,ticks);return ticks};const yAxisFrames=yAxes.map((axis,index)=>{const key=cartesianFrameAxisKey(axis,index);const{side,offset,gutter}=sideLayout[index];const linePosition=side==="right"?plot.x+plot.width+offset:plot.x-offset;const masterIndex=yMasters[index];const scale=yScaleByIndex[index];const requiredValues=index===primaryYAxisIndex?requiredYValues:[];const ticks=axis.show?yRawTicksFor(index):[];const gridLines=index===primaryYAxisIndex&&input.gridLines.y?ticks.filter(t=>shouldIncludeGridLine(t.value,requiredValues,includeRequiredGridLines)).map(t=>({y:t.position,value:t.value})):[];const fullExtent=yResolvedExtents.full[index];const frame={key,axis,scale,ticks,gridLines,side,offset,gutter,linePosition,fullExtent};if(masterIndex>=0)frame.linkedTo=cartesianFrameAxisKey(yAxes[masterIndex],masterIndex);return frame});const primaryY=yAxisFrames[primaryYAxisIndex]??yAxisFrames[0];const yScale=primaryY.scale;const yTicks=primaryY.ticks;const xGridLines=primaryX.gridLines;const yGridLines=primaryY.gridLines;const xScales=Object.fromEntries(xAxisFrames.flatMap((entry,index)=>[[entry.key,entry.scale],[String(index),entry.scale]]));const yScales=Object.fromEntries(yAxisFrames.flatMap((entry,index)=>[[entry.key,entry.scale],[String(index),entry.scale]]));const titleRect=hasTitle?{x:0,y:0,width:outerWidth,height:TITLE_H}:null;const subtitleRect=hasSubtitle?{x:0,y:hasTitle?TITLE_H:0,width:outerWidth,height:SUBTITLE_H}:null;return{plot,xScale,yScale,xAxes:xAxisFrames,xScales,yAxes:yAxisFrames,yScales,xGridLines,yGridLines,xTicks,yTicks,titleRect,subtitleRect,margins,axes:input.axes}}export function isInsidePlot(result,cssX,cssY){const{plot}=result;return cssX>=plot.x&&cssX<=plot.x+plot.width&&cssY>=plot.y&&cssY<=plot.y+plot.height}

package/dist/collection/components/chart/_shared/core/layout/cartesian-render-domain.js

@@ -0,0 +1 @@
+export function cartesianRenderDomain(frame,scale){if(frame?.axis.kind==="log")return void 0;const[min,max]=scale.domain();if(!Number.isFinite(min)||!Number.isFinite(max)||max<=min)return void 0;return frame?.axis.reversed?{min:max,max:min}:{min,max}}

package/dist/collection/components/chart/_shared/core/layout/device-pixel-box.js

@@ -0,0 +1 @@
+export function devicePixelBoxOf(entries,target){const entry=entries.find(e=>e.target===target)??entries[0];const box=entry?.devicePixelContentBoxSize?.[0];if(!box)return void 0;const width=Math.round(box.inlineSize);const height=Math.round(box.blockSize);if(!Number.isFinite(width)||!Number.isFinite(height)||width<=0||height<=0)return void 0;return{width,height}}export function sameDevicePixelBox(a,b){if(a===b)return true;if(!a||!b)return false;return a.width===b.width&&a.height===b.height}

package/dist/collection/components/chart/_shared/core/layout/frame.js

@@ -0,0 +1 @@
+import{computeLegendLayout}from"./legend.js";import{computeTitleLayout}from"./title.js";import{computePlotArea}from"./plot-area.js";function translateRect(rect,dx,dy){return{...rect,x:rect.x+dx,y:rect.y+dy}}function translateRectOrNull(rect,dx,dy){if(rect===null)return null;return translateRect(rect,dx,dy)}function translateLegendResult(result,dx,dy){return{legendRect:translateRectOrNull(result.legendRect,dx,dy),itemRects:result.itemRects.map(ir=>({...ir,x:ir.x+dx,y:ir.y+dy,swatchRect:translateRect(ir.swatchRect,dx,dy),labelRect:translateRect(ir.labelRect,dx,dy)})),remainingOuter:translateRect(result.remainingOuter,dx,dy),style:result.style}}function translateTitleResult(result,dx,dy){return{stripRect:translateRectOrNull(result.stripRect,dx,dy),titleRect:translateRectOrNull(result.titleRect,dx,dy),subtitleRect:translateRectOrNull(result.subtitleRect,dx,dy),remainingOuter:translateRect(result.remainingOuter,dx,dy),style:result.style}}function translatePlotResult(result,dx,dy){const plot={x:result.plot.x+dx,y:result.plot.y+dy,width:result.plot.width,height:result.plot.height};const axisRanges={};const sides=["top","right","bottom","left"];for(const side of sides){const placements=result.axisRanges[side];if(!placements)continue;const horizontal=side==="top"||side==="bottom";axisRanges[side]=placements.map(p=>({range:horizontal?[p.range[0]+dx,p.range[1]+dx]:[p.range[0]+dy,p.range[1]+dy],crossOffset:horizontal?p.crossOffset+dy:p.crossOffset+dx}))}const primaryRanges={};for(const side of sides){const range=result.primaryRanges[side];if(!range)continue;const horizontal=side==="top"||side==="bottom";primaryRanges[side]=horizontal?[range[0]+dx,range[1]+dx]:[range[0]+dy,range[1]+dy]}return{plot,margins:result.margins,axisRanges,primaryRanges}}function clampOuter(value){return Number.isFinite(value)&&value>0?value:0}function hasAnyTitle(input){return Boolean(input.title)||Boolean(input.subtitle)}function hasAnyLegend(input){if(!input.legend)return false;if(!Array.isArray(input.legend.items))return false;return input.legend.items.length>0}export function computeChartFrame(input){const outerWidth=clampOuter(input.outerWidth);const outerHeight=clampOuter(input.outerHeight);const outer={x:0,y:0,width:outerWidth,height:outerHeight};const stages=[];let currentX=0;let currentY=0;let currentWidth=outerWidth;let currentHeight=outerHeight;stages.push("legend");let legendOut=null;if(hasAnyLegend(input)&&input.legend){const legendInput=input.legend;const localResult=computeLegendLayout({outerWidth:currentWidth,outerHeight:currentHeight,items:legendInput.items,position:legendInput.position,direction:legendInput.direction,align:legendInput.align,padding:legendInput.padding,gap:legendInput.gap,swatchSize:legendInput.swatchSize,swatchLabelGap:legendInput.swatchLabelGap,rowGap:legendInput.rowGap,wrap:legendInput.wrap,measureLabel:input.measureLabel});legendOut=translateLegendResult(localResult,currentX,currentY);currentX=legendOut.remainingOuter.x;currentY=legendOut.remainingOuter.y;currentWidth=legendOut.remainingOuter.width;currentHeight=legendOut.remainingOuter.height}stages.push("title");let titleOut=null;if(hasAnyTitle(input)){const titleOpts=input.titleOptions??{};const localResult=computeTitleLayout({outerWidth:currentWidth,outerHeight:currentHeight,title:input.title,subtitle:input.subtitle,position:titleOpts.position,align:titleOpts.align,padding:titleOpts.padding,gap:titleOpts.gap,measureLabel:input.measureLabel});titleOut=translateTitleResult(localResult,currentX,currentY);currentX=titleOut.remainingOuter.x;currentY=titleOut.remainingOuter.y;currentWidth=titleOut.remainingOuter.width;currentHeight=titleOut.remainingOuter.height;if(titleOut.stripRect===null){titleOut=null}}stages.push("plot");const plotLocal=computePlotArea({outerWidth:currentWidth,outerHeight:currentHeight,axes:input.axes??{},padding:input.axisPadding,axisGap:input.axisGap,measureLabel:input.measureLabel});const plotOut=translatePlotResult(plotLocal,currentX,currentY);return{legend:legendOut,title:titleOut,plot:plotOut,meta:{stages,outer}}}

package/dist/collection/components/chart/_shared/core/layout/index.js

@@ -0,0 +1 @@
+export{computePlotArea}from"./plot-area.js";export{computeTitleLayout}from"./title.js";export{computeLegendLayout}from"./legend.js";export{createLegendToggleState,createLegendPositionState,dragLegendBy,hitTestLegend,isLegendItemDisabled,nextFocusableItem,toggleLegendItem}from"./legend-interaction.js";export{computeChartFrame}from"./frame.js";export{computeCartesianFrame,isInsidePlot}from"./cartesian-frame.js";export{cartesianCrosshairGeometry,cartesianHitTest,cartesianTooltipAnchor}from"./cartesian-frame-interaction.js";export{thinAxisTicks,thinGridLines}from"./axis-label-thinning.js";export*from"./device-pixel-box.js";

package/dist/collection/components/chart/_shared/core/layout/label-geometry.js

@@ -0,0 +1 @@
+export function labelStrokeOverlapsBox(stroke,box){const{a,b,width}=stroke;if(!(width>0&&box.width>0&&box.height>0)||![a.x,a.y,b.x,b.y,width,box.x,box.y,box.width,box.height].every(Number.isFinite))return false;const dx=b.x-a.x,dy=b.y-a.y;let lo=0,hi=1;for(const[origin,delta,min,max]of[[a.x,dx,box.x,box.x+box.width],[a.y,dy,box.y,box.y+box.height]]){if(delta===0){if(origin<min||origin>max){lo=1;hi=0;break}}else{const p=(min-origin)/delta,q=(max-origin)/delta;lo=Math.max(lo,Math.min(p,q));hi=Math.min(hi,Math.max(p,q))}}if(lo<=hi)return true;const pointBox=p=>Math.hypot(Math.max(box.x-p.x,0,p.x-box.x-box.width),Math.max(box.y-p.y,0,p.y-box.y-box.height));const pointSegment=(x,y)=>{const length=dx*dx+dy*dy,t=length?Math.max(0,Math.min(1,((x-a.x)*dx+(y-a.y)*dy)/length)):0;return Math.hypot(x-a.x-t*dx,y-a.y-t*dy)};return Math.min(pointBox(a),pointBox(b),...[[box.x,box.y],[box.x+box.width,box.y],[box.x,box.y+box.height],[box.x+box.width,box.y+box.height]].map(([x,y])=>pointSegment(x,y)))<=width/2}export const labelBoxesOverlap=(a,b)=>a.x<b.x+b.width&&a.x+a.width>b.x&&a.y<b.y+b.height&&a.y+a.height>b.y;export function labelTriangleOverlapsBox(points,box){if(points.length!==3)return false;const[a,b,c]=points;return labelTriangleCoordinatesOverlapBox(a.x,a.y,b.x,b.y,c.x,c.y,box)}export function labelTriangleCoordinatesOverlapBox(ax,ay,bx,by,cx,cy,box){if(!(box.width>0&&box.height>0)||(bx-ax)*(cy-ay)-(by-ay)*(cx-ax)===0)return false;const right=box.x+box.width,bottom=box.y+box.height;if(Math.min(ax,bx,cx)>=right||Math.max(ax,bx,cx)<=box.x||Math.min(ay,by,cy)>=bottom||Math.max(ay,by,cy)<=box.y)return false;for(let i=0;i<3;i++){const x=i===0?ay-by:i===1?by-cy:cy-ay,y=i===0?bx-ax:i===1?cx-bx:ax-cx;const a=ax*x+ay*y,b=bx*x+by*y,c=cx*x+cy*y;const r0=box.x*x+box.y*y,r1=right*x+box.y*y,r2=right*x+bottom*y,r3=box.x*x+bottom*y;if(Math.max(a,b,c)<Math.min(r0,r1,r2,r3)||Math.max(r0,r1,r2,r3)<Math.min(a,b,c))return false}return true}

package/dist/collection/components/chart/_shared/core/layout/label-obstacle-index.js

@@ -0,0 +1 @@
+import{labelBoxesOverlap,labelTriangleOverlapsBox,labelTriangleCoordinatesOverlapBox,labelStrokeOverlapsBox}from"./label-geometry.js";export class LabelObstacleIndex{left;top;columns;rows;cells;query=0;cell;constructor(clip,cell=32){cell=Math.max(Number.isFinite(cell)&&cell>0?cell:32,clip.width/256,clip.height/256);this.cell=cell;this.left=Math.floor(clip.x/cell);this.top=Math.floor(clip.y/cell);this.columns=Math.max(1,Math.floor((clip.x+clip.width)/cell)-this.left+1);this.rows=Math.max(1,Math.floor((clip.y+clip.height)/cell)-this.top+1);this.cells=new Array(this.columns*this.rows)}bounds(box){return[Math.max(0,Math.floor(box.x/this.cell)-this.left),Math.min(this.columns-1,Math.floor((box.x+box.width)/this.cell)-this.left),Math.max(0,Math.floor(box.y/this.cell)-this.top),Math.min(this.rows-1,Math.floor((box.y+box.height)/this.cell)-this.top)]}add(box,triangle,stroke,test){const obstacle={box,triangle,stroke,test,query:0},[x0,x1,y0,y1]=this.bounds(box);for(let y=y0;y<=y1;y++)for(let x=x0;x<=x1;x++)(this.cells[y*this.columns+x]??=[]).push(obstacle)}addTriangleMesh(triangles,view,origin,bounds){if(!triangles.length)return;const{scaleX:sx,scaleY:sy,translateX:tx,translateY:ty}=view;if(bounds){const x0=origin.x+bounds.x*sx+tx,x1=x0+bounds.width*sx,y0=origin.y+bounds.y*sy+ty,y1=y0+bounds.height*sy;const box={x:Math.min(x0,x1),y:Math.min(y0,y1),width:Math.abs(x1-x0),height:Math.abs(y1-y0)};let fine;this.add(box,void 0,void 0,candidate=>{if(!fine){fine=new LabelObstacleIndex(box);fine.addTriangleMesh(triangles,view,origin)}return fine.overlaps(candidate)});return}for(let first=0;first<triangles.length;first+=12){const end=Math.min(first+12,triangles.length);let left=Infinity,top=Infinity,right=-Infinity,bottom=-Infinity;for(let i=first;i<end;i++){const t=triangles[i];left=Math.min(left,t.a[0],t.b[0],t.c[0]);right=Math.max(right,t.a[0],t.b[0],t.c[0]);top=Math.min(top,t.a[1],t.b[1],t.c[1]);bottom=Math.max(bottom,t.a[1],t.b[1],t.c[1])}const x0=origin.x+left*sx+tx,x1=origin.x+right*sx+tx,y0=origin.y+top*sy+ty,y1=origin.y+bottom*sy+ty;this.add({x:Math.min(x0,x1),y:Math.min(y0,y1),width:Math.abs(x1-x0),height:Math.abs(y1-y0)},void 0,void 0,box=>{for(let i=first;i<end;i++){const t=triangles[i];if(labelTriangleCoordinatesOverlapBox(origin.x+t.a[0]*sx+tx,origin.y+t.a[1]*sy+ty,origin.x+t.b[0]*sx+tx,origin.y+t.b[1]*sy+ty,origin.x+t.c[0]*sx+tx,origin.y+t.c[1]*sy+ty,box))return true}return false})}}overlaps(box){const id=++this.query,[x0,x1,y0,y1]=this.bounds(box);for(let y=y0;y<=y1;y++)for(let x=x0;x<=x1;x++)for(const obstacle of this.cells[y*this.columns+x]??[]){if(obstacle.query===id)continue;obstacle.query=id;if(labelBoxesOverlap(box,obstacle.box)&&(!obstacle.triangle||labelTriangleOverlapsBox(obstacle.triangle,box))&&(!obstacle.stroke||labelStrokeOverlapsBox(obstacle.stroke,box))&&(!obstacle.test||obstacle.test(box)))return true}return false}}

package/dist/collection/components/chart/_shared/core/layout/legend-interaction.js

@@ -0,0 +1 @@
+function isFiniteNumber(value){return typeof value==="number"&&Number.isFinite(value)}function isValidIndex(index,count){return isFiniteNumber(index)&&Number.isInteger(index)&&index>=0&&index<count}function coerceTolerance(raw){if(raw===void 0)return 0;if(!isFiniteNumber(raw)||raw<0)return 0;return raw}function pointInRect(px,py,rect,tolerance){const left=rect.x-tolerance;const top=rect.y-tolerance;const right=rect.x+rect.width+tolerance;const bottom=rect.y+rect.height+tolerance;return px>=left&&px<=right&&py>=top&&py<=bottom}function createReadonlySet(values){const backing=new Set(values);const readonly=new Proxy(backing,{get(target,prop){if(prop==="add"||prop==="delete"||prop==="clear"){return()=>{throw new TypeError("[Syidax] sy-legend: disabled set is readonly.")}}const value=Reflect.get(target,prop,target);return typeof value==="function"?value.bind(target):value},set(){return false},defineProperty(){return false},deleteProperty(){return false}});return Object.freeze(readonly)}function freezeToggleState(state){return Object.freeze({disabled:createReadonlySet(state.disabled),count:state.count})}export function hitTestLegend(input){const{legendRect,itemRects,pointerX,pointerY}=input;const tolerance=coerceTolerance(input.tolerance);if(!isFiniteNumber(pointerX)||!isFiniteNumber(pointerY)){return{index:null,itemRect:null}}if(!Array.isArray(itemRects)||itemRects.length===0){return{index:null,itemRect:null}}if(!pointInRect(pointerX,pointerY,legendRect,tolerance)){return{index:null,itemRect:null}}for(let i=0;i<itemRects.length;i++){const rect=itemRects[i];if(pointInRect(pointerX,pointerY,rect,tolerance)){return{index:i,itemRect:rect}}}return{index:null,itemRect:null}}export function createLegendToggleState(itemCount,initiallyDisabled){const count=isFiniteNumber(itemCount)&&itemCount>0?Math.floor(itemCount):0;const disabled=new Set;if(count>0&&Array.isArray(initiallyDisabled)){for(const candidate of initiallyDisabled){if(isValidIndex(candidate,count)){disabled.add(candidate)}}}return freezeToggleState({disabled,count})}export function toggleLegendItem(state,index){if(!isValidIndex(index,state.count)){console.warn(`[Syidax] sy-legend: toggleLegendItem received invalid index ${index} (count ${state.count}); ignored.`);return state}const next=new Set(state.disabled);if(next.has(index)){next.delete(index)}else{next.add(index)}return freezeToggleState({disabled:next,count:state.count})}export function isLegendItemDisabled(state,index){if(!isValidIndex(index,state.count))return false;return state.disabled.has(index)}export function nextFocusableItem(state,direction){if(state.count<=0)return state;let nextIndex;if(state.focusedIndex===null){nextIndex=direction===1?0:state.count-1}else{const raw=state.focusedIndex+direction;if(raw<0){nextIndex=state.count-1}else if(raw>=state.count){nextIndex=0}else{nextIndex=raw}}if(nextIndex===state.focusedIndex)return state;return Object.freeze({focusedIndex:nextIndex,count:state.count})}export function createLegendPositionState(x,y){const safeX=Number.isFinite(x)?x:0;const safeY=Number.isFinite(y)?y:0;return Object.freeze({x:safeX,y:safeY})}export function dragLegendBy(state,dx,dy,bounds,legendSize){const safeDx=Number.isFinite(dx)?dx:0;const safeDy=Number.isFinite(dy)?dy:0;let rawX=state.x+safeDx;let rawY=state.y+safeDy;const boundsValid=Number.isFinite(bounds.x)&&Number.isFinite(bounds.y)&&Number.isFinite(bounds.width)&&bounds.width>=0&&Number.isFinite(bounds.height)&&bounds.height>=0;if(boundsValid){const lw=Number.isFinite(legendSize.width)&&legendSize.width>=0?legendSize.width:0;const lh=Number.isFinite(legendSize.height)&&legendSize.height>=0?legendSize.height:0;const minX=bounds.x;const maxX=bounds.x+Math.max(0,bounds.width-lw);const minY=bounds.y;const maxY=bounds.y+Math.max(0,bounds.height-lh);rawX=Math.max(minX,Math.min(rawX,maxX));rawY=Math.max(minY,Math.min(rawY,maxY))}if(rawX===state.x&&rawY===state.y)return state;return Object.freeze({x:rawX,y:rawY})}