@toclocoinc/lattice-grid 1.65.0 → 1.67.0

package/modules/vue.min.js

@@ -1,5 +1,5 @@
 /*!
- * Lattice Grid 1.65.0, vue module
+ * Lattice Grid 1.67.0, vue module
  * Copyright (c) 2026 TOCLOCO Inc. All rights reserved.
  * https://latticegrid.dev
  */
@@ -18,6 +18,403 @@ if(!fn)throw new Error('[lattice] missing module: '+id);
 fn(exports,__req);
 return exports;
 }
+__def("packages/core/src/internal/util.js",function(__exports,__req){
+'use strict';
+Object.defineProperty(__exports,"VERSION",{enumerable:true,get:function(){return VERSION;}});
+Object.defineProperty(__exports,"reportedWarnings",{enumerable:true,get:function(){return reportedWarnings;}});
+Object.defineProperty(__exports,"warnOnce",{enumerable:true,get:function(){return warnOnce;}});
+Object.defineProperty(__exports,"infoOnce",{enumerable:true,get:function(){return infoOnce;}});
+Object.defineProperty(__exports,"resetWarnings",{enumerable:true,get:function(){return resetWarnings;}});
+Object.defineProperty(__exports,"fail",{enumerable:true,get:function(){return fail;}});
+Object.defineProperty(__exports,"invariant",{enumerable:true,get:function(){return invariant;}});
+Object.defineProperty(__exports,"DEV",{enumerable:true,get:function(){return DEV;}});
+Object.defineProperty(__exports,"isObject",{enumerable:true,get:function(){return isObject;}});
+Object.defineProperty(__exports,"isFunction",{enumerable:true,get:function(){return isFunction;}});
+Object.defineProperty(__exports,"isNil",{enumerable:true,get:function(){return isNil;}});
+Object.defineProperty(__exports,"isBlank",{enumerable:true,get:function(){return isBlank;}});
+Object.defineProperty(__exports,"isCtor",{enumerable:true,get:function(){return isCtor;}});
+Object.defineProperty(__exports,"pathGetter",{enumerable:true,get:function(){return pathGetter;}});
+Object.defineProperty(__exports,"pathSetter",{enumerable:true,get:function(){return pathSetter;}});
+Object.defineProperty(__exports,"getPath",{enumerable:true,get:function(){return getPath;}});
+Object.defineProperty(__exports,"setPath",{enumerable:true,get:function(){return setPath;}});
+Object.defineProperty(__exports,"humanise",{enumerable:true,get:function(){return humanise;}});
+Object.defineProperty(__exports,"escapeHtml",{enumerable:true,get:function(){return escapeHtml;}});
+Object.defineProperty(__exports,"titleCase",{enumerable:true,get:function(){return titleCase;}});
+Object.defineProperty(__exports,"expand",{enumerable:true,get:function(){return expand;}});
+Object.defineProperty(__exports,"toArray",{enumerable:true,get:function(){return toArray;}});
+Object.defineProperty(__exports,"merge",{enumerable:true,get:function(){return merge;}});
+Object.defineProperty(__exports,"mergeRow",{enumerable:true,get:function(){return mergeRow;}});
+Object.defineProperty(__exports,"Lru",{enumerable:true,get:function(){return Lru;}});
+Object.defineProperty(__exports,"collator",{enumerable:true,get:function(){return collator;}});
+Object.defineProperty(__exports,"defaultCompare",{enumerable:true,get:function(){return defaultCompare;}});
+Object.defineProperty(__exports,"now",{enumerable:true,get:function(){return now;}});
+Object.defineProperty(__exports,"nextFrame",{enumerable:true,get:function(){return nextFrame;}});
+Object.defineProperty(__exports,"cancelFrame",{enumerable:true,get:function(){return cancelFrame;}});
+Object.defineProperty(__exports,"frameBatched",{enumerable:true,get:function(){return frameBatched;}});
+Object.defineProperty(__exports,"settleDebounce",{enumerable:true,get:function(){return settleDebounce;}});
+Object.defineProperty(__exports,"whenIdle",{enumerable:true,get:function(){return whenIdle;}});
+Object.defineProperty(__exports,"uid",{enumerable:true,get:function(){return uid;}});
+const STAMPED_VERSION="1.67.0";
+async function resolveVersion(){
+if(STAMPED_VERSION!=='0.0.0-source')return STAMPED_VERSION;
+return STAMPED_VERSION;
+}
+const VERSION="1.67.0";
+const warned=new Set();
+const WARNED_LIMIT=2000;
+function rememberWarned(key){
+warned.add(key);
+if(warned.size>WARNED_LIMIT){
+const oldest=warned.values().next().value;
+if(oldest!==undefined)warned.delete(oldest);
+}
+}
+const reported=[];
+const REPORT_LIMIT=500;
+function record(key,level,message){
+reported.push({
+key,
+level,
+message:message.map((m)=>(typeof m==='string'?m:safeString(m))).join(' '),
+at:Date.now(),
+});
+if(reported.length>REPORT_LIMIT)reported.shift();
+}
+function safeString(value){
+if(value instanceof Error)return value.message;
+try{return JSON.stringify(value);}catch{return String(value);}
+}
+function reportedWarnings(){return reported.map((r)=>({...r}));}
+function warnOnce(key,...message){
+if(warned.has(key))return;
+rememberWarned(key);
+record(key,'warn',message);
+console.warn('[lattice]',...message);
+}
+function infoOnce(key,...message){
+if(warned.has(key))return;
+rememberWarned(key);
+record(key,'info',message);
+console.info('[lattice]',...message);
+}
+function resetWarnings(){
+warned.clear();
+reported.length=0;
+}
+function fail(message,extra){
+const err=new Error(`[lattice] ${message}`);
+if(extra!==undefined)err.cause=extra;
+throw err;
+}
+function invariant(condition,message){
+if(!condition)fail(message);
+}
+const DEV=(()=>{
+try{
+return!(typeof process!=='undefined'&&process.env
+&&process.env.NODE_ENV==='production');
+}catch{
+return true;
+}
+})();
+function isObject(v){
+return v!==null&&typeof v==='object'&&!Array.isArray(v);
+}
+function isFunction(v){
+return typeof v==='function';
+}
+function isNil(v){
+return v===null||v===undefined;
+}
+function isBlank(v){
+return v===null||v===undefined||v==='';
+}
+function isCtor(v){
+if(typeof v!=='function')return false;
+if(/^class[\s{]/.test(Function.prototype.toString.call(v)))return true;
+return!!(v.prototype&&Object.getOwnPropertyNames(v.prototype).length>1);
+}
+const pathCache=new Map();
+function pathGetter(path){
+let fn=pathCache.get(path);
+if(fn)return fn;
+if(!path.includes('.')){
+fn=(o)=>(o==null?undefined:o[path]);
+}else{
+const parts=path.split('.');
+const n=parts.length;
+fn=(o)=>{
+let cur=o;
+for(let i=0;i<n;i++){
+if(cur==null)return undefined;
+cur=cur[parts[i]];
+}
+return cur;
+};
+}
+pathCache.set(path,fn);
+return fn;
+}
+const setterCache=new Map();
+function pathSetter(path){
+let fn=setterCache.get(path);
+if(fn)return fn;
+if(!path.includes('.')){
+fn=(o,v)=>{if(o!=null)o[path]=v;};
+}else{
+const parts=path.split('.');
+const last=parts.length-1;
+fn=(o,v)=>{
+let cur=o;
+for(let i=0;i<last;i++){
+if(cur==null)return;
+const k=parts[i];
+if(cur[k]==null)cur[k]={};
+cur=cur[k];
+}
+if(cur!=null)cur[parts[last]]=v;
+};
+}
+setterCache.set(path,fn);
+return fn;
+}
+function getPath(obj,path){
+return pathGetter(path)(obj);
+}
+function setPath(obj,path,value){
+pathSetter(path)(obj,value);
+}
+function humanise(field){
+if(!field)return'';
+const leaf=field.includes('.')?field.slice(field.lastIndexOf('.')+1):field;
+return leaf
+.replace(/[_-]+/g,' ')
+.replace(/([a-z0-9])([A-Z])/g,'$1 $2')
+.replace(/([A-Z]+)([A-Z][a-z])/g,'$1 $2')
+.replace(/\s+/g,' ')
+.trim()
+.replace(/^./,(c)=>c.toUpperCase());
+}
+const ESCAPES={'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;',"'":'&#39;'};
+function escapeHtml(s){
+const str=s==null?'':String(s);
+return/[&<>"']/.test(str)?str.replace(/[&<>"']/g,(c)=>ESCAPES[c]):str;
+}
+function titleCase(s){
+return String(s).replace(/\w\S*/g,(t)=>t[0].toUpperCase()+t.slice(1).toLowerCase());
+}
+function expand(value,key,whenTrue){
+if(value===undefined)return undefined;
+if(value===true)return{enabled:true,...whenTrue};
+if(value===false)return{enabled:false};
+if(isObject(value))return value;
+return{[key]:value,enabled:true};
+}
+function toArray(v){
+if(v===undefined||v===null)return[];
+return Array.isArray(v)?v:[v];
+}
+const MERGE_FORBIDDEN_KEYS=Object.freeze(new Set(['__proto__','constructor','prototype']));
+function merge(a,b){
+if(!isObject(a))return isObject(b)?{...b}:b;
+if(!isObject(b))return b===undefined?a:b;
+const out={...a};
+for(const k of Object.keys(b)){
+if(MERGE_FORBIDDEN_KEYS.has(k))continue;
+const bv=b[k];
+if(bv===undefined)continue;
+out[k]=isObject(bv)&&isObject(out[k])?merge(out[k],bv):bv;
+}
+return out;
+}
+function mergeRow(previous,patch){
+if(!isObject(previous)||!isObject(patch)||previous===patch)return patch;
+const out=Object.create(Object.getPrototypeOf(previous));
+Object.assign(out,previous,patch);
+return out;
+}
+class Lru{
+#max;
+#map=new Map();
+#onEvict;
+constructor(max=256,onEvict=null){
+this.#max=max;
+this.#onEvict=onEvict;
+}
+get size(){
+return this.#map.size;
+}
+get max(){
+return this.#max;
+}
+set max(v){
+this.#max=v;
+this.#trim();
+}
+has(k){
+return this.#map.has(k);
+}
+get(k){
+const m=this.#map;
+if(!m.has(k))return undefined;
+const v=m.get(k);
+m.delete(k);
+m.set(k,v);
+return v;
+}
+peek(k){
+return this.#map.get(k);
+}
+set(k,v){
+const m=this.#map;
+if(m.has(k))m.delete(k);
+m.set(k,v);
+this.#trim();
+return v;
+}
+delete(k){
+const v=this.#map.get(k);
+if(this.#map.delete(k)&&this.#onEvict)this.#onEvict(v,k);
+return v;
+}
+clear(){
+if(this.#onEvict)for(const[k,v]of this.#map)this.#onEvict(v,k);
+this.#map.clear();
+}
+keys(){
+return this.#map.keys();
+}
+values(){
+return this.#map.values();
+}
+#trim(){
+const m=this.#map;
+while(m.size>this.#max){
+const oldest=m.keys().next().value;
+const v=m.get(oldest);
+m.delete(oldest);
+if(this.#onEvict)this.#onEvict(v,oldest);
+}
+}
+}
+const collators=new Map();
+function collator(locale,opts){
+const key=`${locale||''}|${opts?JSON.stringify(opts):''}`;
+let c=collators.get(key);
+if(!c){
+c=new Intl.Collator(locale||undefined,{
+numeric:true,sensitivity:'variant',...opts,
+});
+collators.set(key,c);
+}
+return c;
+}
+function defaultCompare(a,b){
+if(a===b)return 0;
+if(a===null||a===undefined)return 1;
+if(b===null||b===undefined)return-1;
+if(typeof a==='number'&&typeof b==='number'){
+if(Number.isNaN(a))return Number.isNaN(b)?0:1;
+if(Number.isNaN(b))return-1;
+return a<b?-1:a>b?1:0;
+}
+const sa=String(a);
+const sb=String(b);
+return sa<sb?-1:sa>sb?1:0;
+}
+function now(){
+return typeof performance!=='undefined'&&performance.now
+?performance.now()
+:Date.now();
+}
+const hasRaf=typeof requestAnimationFrame==='function';
+function nextFrame(fn){
+if(hasRaf)return requestAnimationFrame(fn);
+return setTimeout(()=>fn(now()),16);
+}
+function cancelFrame(handle){
+if(handle==null)return;
+if(hasRaf)cancelAnimationFrame(handle);
+else clearTimeout(handle);
+}
+function frameBatched(fn){
+let handle=null;
+let lastArgs=null;
+const run=()=>{
+handle=null;
+const a=lastArgs;
+lastArgs=null;
+fn(...(a||[]));
+};
+const wrapped=(...args)=>{
+lastArgs=args;
+if(handle===null)handle=nextFrame(run);
+};
+wrapped.cancel=()=>{
+cancelFrame(handle);
+handle=null;
+lastArgs=null;
+};
+wrapped.flush=()=>{
+if(handle!==null){
+cancelFrame(handle);
+run();
+}
+};
+return wrapped;
+}
+function settleDebounce(fn,waitMs){
+let timer=null;
+let held=null;
+const trailing=()=>{
+timer=null;
+if(held===null)return;
+const args=held;
+held=null;
+fn(...args);
+arm();
+};
+const arm=()=>{
+timer=setTimeout(trailing,waitMs);
+if(typeof timer?.unref==='function')timer.unref();
+};
+const wrapped=(...args)=>{
+if(timer===null){
+fn(...args);
+arm();
+}else{
+held=args;
+clearTimeout(timer);
+arm();
+}
+};
+wrapped.flush=()=>{
+if(timer!==null)clearTimeout(timer);
+timer=null;
+if(held===null)return;
+const args=held;
+held=null;
+fn(...args);
+};
+wrapped.cancel=()=>{
+if(timer!==null)clearTimeout(timer);
+timer=null;
+held=null;
+};
+wrapped.pending=()=>timer!==null||held!==null;
+return wrapped;
+}
+function whenIdle(fn,timeout=50){
+if(typeof requestIdleCallback==='function'){
+return requestIdleCallback(fn,{timeout});
+}
+return setTimeout(()=>fn({timeRemaining:()=>0,didTimeout:true}),1);
+}
+let idSeq=0;
+function uid(prefix='l'){
+return`${prefix}${(++idSeq).toString(36)}`;
+}
+});
 __def("packages/modules/shared/adapter.js",function(__exports,__req){
 'use strict';
 Object.defineProperty(__exports,"EVENT_NAMES",{enumerable:true,get:function(){return EVENT_NAMES;}});
@@ -172,72 +569,792 @@ grid.destroy();
 };
 }
 });
+__def("packages/modules/react/viewers.js",function(__exports,__req){
+'use strict';
+Object.defineProperty(__exports,"VIEWER_EVENTS",{enumerable:true,get:function(){return VIEWER_EVENTS;}});
+Object.defineProperty(__exports,"VIEWER_APPLY",{enumerable:true,get:function(){return VIEWER_APPLY;}});
+Object.defineProperty(__exports,"VIEWER_BULK_UPDATE",{enumerable:true,get:function(){return VIEWER_BULK_UPDATE;}});
+Object.defineProperty(__exports,"viewerHandlerName",{enumerable:true,get:function(){return viewerHandlerName;}});
+Object.defineProperty(__exports,"partitionViewerProps",{enumerable:true,get:function(){return partitionViewerProps;}});
+Object.defineProperty(__exports,"createViewerController",{enumerable:true,get:function(){return createViewerController;}});
+const __m0=__req("packages/core/src/internal/util.js");
+const warnOnce=__m0["warnOnce"];
+const VIEWER_EVENTS=Object.freeze({
+kpi:Object.freeze([
+'tile:click','tile:dblclick','tile:contextmenu','node:toggle','change',
+]),
+kanban:Object.freeze([
+'card:click','card:dblclick','card:contextmenu',
+'card:move','card:reverted','card:confirmed','selection:changed','column:collapse','card:add',
+'drag:start','drag:end','swimlane:collapse','swimlane:reorder','column:reorder',
+'filter:changed','sprint:changed','epic:changed','card:expand','card:drill','card:edit',
+'card:sla',
+'beforeMove','beforeAdd','beforeEdit',
+'beforeLaneReorder','beforeColumnReorder','beforeColumnChange',
+'move:cancelled','add:cancelled','edit:cancelled',
+'laneReorder:cancelled','columnReorder:cancelled','columnChange:cancelled',
+]),
+tabs:Object.freeze(['beforeTabChange','tab:changed','tabChange:cancelled']),
+chart:Object.freeze(['click','hover','leave','draw','legend']),
+gantt:Object.freeze(['schedule','error']),
+layout:Object.freeze([
+'layout:changed','window:moved','window:resized','window:closed',
+'beforeWindowClose','windowClose:cancelled',
+]),
+router:Object.freeze(['metrics']),
+});
+const VIEWER_APPLY=Object.freeze({
+kpi:Object.freeze({
+rows:(kpi,value)=>kpi.setRows(Array.isArray(value)?value:[]),
+}),
+kanban:Object.freeze({
+rows:(board,value)=>board.setRows(Array.isArray(value)?value:[]),
+quickFilter:(board,value)=>board.setQuickFilter(typeof value==='string'?value:''),
+sprint:(board,value)=>board.setSprint(value),
+epic:(board,value)=>board.setEpic(value),
+loading:(board,value)=>board.setLoading(!!value),
+error:(board,value)=>board.setError(value??null),
+}),
+gantt:Object.freeze({
+tasks:(gantt,value)=>gantt.setTasks(Array.isArray(value)?value:[]),
+dependencies:(gantt,value)=>gantt.setDependencies(Array.isArray(value)?value:[]),
+}),
+tabs:Object.freeze({
+active:(tabs,value)=>{if(typeof value==='string')tabs.activate(value);},
+}),
+chart:Object.freeze({}),
+layout:Object.freeze({}),
+});
+const VIEWER_BULK_UPDATE=Object.freeze({chart:'update'});
+function viewerHandlerName(event){
+const parts=String(event).split(':');
+return`on${parts.map((p)=>p.charAt(0).toUpperCase()+p.slice(1)).join('')}`;
+}
+const BY_HANDLER=Object.freeze(Object.fromEntries(
+Object.entries(VIEWER_EVENTS).map(([viewer,events])=>[
+viewer,
+Object.freeze(Object.fromEntries(events.map((e)=>[viewerHandlerName(e),e]))),
+]),
+));
+function partitionViewerProps(viewer,props){
+const byHandler=BY_HANDLER[viewer]||{};
+const applies=VIEWER_APPLY[viewer]||{};
+const config={};
+const live={};
+const handlers={};
+for(const[key,value]of Object.entries(props||{})){
+if(Object.hasOwn(byHandler,key)){handlers[key]=value;continue;}
+if(Object.hasOwn(applies,key)){live[key]=value;config[key]=value;continue;}
+config[key]=value;
+}
+return{config,live,handlers};
+}
+function createViewerController(opts){
+const viewer=String(opts.viewer);
+const mount=opts.mount;
+const label=opts.name||viewer;
+if(typeof mount!=='function'){
+throw new TypeError(
+`createViewerController needs a mount factory for "${viewer}"; pass the module's own `
++'factory in, e.g. { createKPI } from lattice-grid/modules/kpi.');
+}
+const initial=partitionViewerProps(viewer,opts.props||{});
+const instance=mount(opts.element,{...initial.config});
+if(!instance||typeof instance!=='object'){
+throw new TypeError(`the ${label} factory returned no instance; nothing can be driven.`);
+}
+let handlers=initial.handlers;
+let config=initial.config;
+const live={...initial.live};
+const off=[];
+if(typeof instance.on==='function'){
+for(const event of VIEWER_EVENTS[viewer]||[]){
+const prop=viewerHandlerName(event);
+const stop=instance.on(event,(payload)=>{
+const fn=handlers[prop];
+if(typeof fn==='function')fn(payload);
+});
+if(typeof stop==='function')off.push(stop);
+}
+}
+const bulk=VIEWER_BULK_UPDATE[viewer];
+const applies=VIEWER_APPLY[viewer]||{};
+let destroyed=false;
+return{
+instance,
+update(next){
+if(destroyed)return;
+const parts=partitionViewerProps(viewer,next||{});
+handlers=parts.handlers;
+const changed={};
+for(const[key,value]of Object.entries(parts.config)){
+if(!Object.is(config[key],value))changed[key]=value;
+}
+config=parts.config;
+if(!Object.keys(changed).length)return;
+const unapplied=[];
+for(const key of Object.keys(changed)){
+const apply=applies[key];
+if(apply){
+apply(instance,changed[key]);
+live[key]=changed[key];
+continue;
+}
+if(bulk&&typeof instance[bulk]==='function')continue;
+unapplied.push(key);
+}
+if(bulk&&typeof instance[bulk]==='function'){
+const spec={};
+for(const key of Object.keys(changed))if(!applies[key])spec[key]=changed[key];
+if(Object.keys(spec).length)instance[bulk](spec);
+}
+if(unapplied.length){
+warnOnce(`react.viewer.${viewer}.mountOnly.${unapplied.join('.')}`,
+`${label}: ${unapplied.map((k)=>`\`${k}\``).join(', ')} changed, but `
++`${label} takes ${unapplied.length===1?'it':'them'} only when the viewer is `
++'created. Nothing was applied and the viewer was NOT rebuilt — rebuilding it silently '
++'would throw away scroll position, selection and expansion. Give the component a '
++'`key` that changes when this must take effect, so the rebuild is yours and visible, '
++'or drive the instance through the ref.');
+}
+},
+destroy(){
+if(destroyed)return;
+destroyed=true;
+for(const stop of off){
+try{stop();}catch{}
+}
+off.length=0;
+if(typeof instance.destroy==='function')instance.destroy();
+},
+};
+}
+});
 __def("packages/modules/vue/index.js",function(__exports,__req){
 'use strict';
 Object.defineProperty(__exports,"EVENT_NAMES",{enumerable:true,get:function(){return EVENT_NAMES;}});
 Object.defineProperty(__exports,"dashedName",{enumerable:true,get:function(){return dashedName;}});
+Object.defineProperty(__exports,"VIEWER_EVENTS",{enumerable:true,get:function(){return VIEWER_EVENTS;}});
+Object.defineProperty(__exports,"VIEWER_APPLY",{enumerable:true,get:function(){return VIEWER_APPLY;}});
+Object.defineProperty(__exports,"viewerHandlerName",{enumerable:true,get:function(){return viewerHandlerName;}});
+Object.defineProperty(__exports,"createViewerController",{enumerable:true,get:function(){return createViewerController;}});
+Object.defineProperty(__exports,"DEFAULT_GRID_NAME",{enumerable:true,get:function(){return DEFAULT_GRID_NAME;}});
 Object.defineProperty(__exports,"createLatticeGrid",{enumerable:true,get:function(){return createLatticeGrid;}});
+Object.defineProperty(__exports,"createLatticeGridContext",{enumerable:true,get:function(){return createLatticeGridContext;}});
+Object.defineProperty(__exports,"createLatticeViewer",{enumerable:true,get:function(){return createLatticeViewer;}});
+Object.defineProperty(__exports,"createLatticeKPI",{enumerable:true,get:function(){return createLatticeKPI;}});
+Object.defineProperty(__exports,"createLatticeChart",{enumerable:true,get:function(){return createLatticeChart;}});
+Object.defineProperty(__exports,"createLatticeKanban",{enumerable:true,get:function(){return createLatticeKanban;}});
+Object.defineProperty(__exports,"createLatticeGantt",{enumerable:true,get:function(){return createLatticeGantt;}});
+Object.defineProperty(__exports,"createLatticeLayout",{enumerable:true,get:function(){return createLatticeLayout;}});
+Object.defineProperty(__exports,"createLatticeTabs",{enumerable:true,get:function(){return createLatticeTabs;}});
+Object.defineProperty(__exports,"createLatticeRouter",{enumerable:true,get:function(){return createLatticeRouter;}});
+Object.defineProperty(__exports,"createLatticeVue",{enumerable:true,get:function(){return createLatticeVue;}});
 Object.defineProperty(__exports,"default",{enumerable:true,get:function(){return __default;}});
-const __m0=__req("packages/modules/shared/adapter.js");
-const createGridController=__m0["createGridController"];
-const EVENT_NAMES=__m0["EVENT_NAMES"];
-const dashedName=__m0["dashedName"];
-const isHandlerProp=__m0["isHandlerProp"];
-const aliasConfigKey=__m0["aliasConfigKey"];
+const __m0=__req("packages/core/src/internal/util.js");
+const warnOnce=__m0["warnOnce"];
+const __m1=__req("packages/modules/shared/adapter.js");
+const createGridController=__m1["createGridController"];
+const EVENT_NAMES=__m1["EVENT_NAMES"];
+const dashedName=__m1["dashedName"];
+const handlerName=__m1["handlerName"];
+const isHandlerProp=__m1["isHandlerProp"];
+const aliasConfigKey=__m1["aliasConfigKey"];
+const __m2=__req("packages/modules/react/viewers.js");
+const VIEWER_EVENTS=__m2["VIEWER_EVENTS"];
+const VIEWER_APPLY=__m2["VIEWER_APPLY"];
+const viewerHandlerName=__m2["viewerHandlerName"];
+const createViewerController=__m2["createViewerController"];
+const DEFAULT_GRID_NAME='default';
+const HOST_ATTRS=new Set(['class','style','id']);
+const GRID_REGISTRY_KEY=Symbol.for('lattice.vue.gridRegistry');
+const ROUTER_KEY=Symbol.for('lattice.vue.router');
+const ATTRS_PROBE=Symbol.for('lattice.vue.attrsProbe');
+function requireVue(vue,fn){
+if(!vue||typeof vue.h!=='function'){
+throw new TypeError(`${fn} needs the Vue runtime: ${fn}({ vue, … }).`);
+}
+}
+function define(vue,definition){
+return typeof vue.defineComponent==='function'?vue.defineComponent(definition):definition;
+}
+function configKeys(attrs){
+const out=[];
+const names=Object.keys(attrs||{});
+const present=new Set(names);
+for(const from of names){
+if(HOST_ATTRS.has(from))continue;
+if(isHandlerProp(from))continue;
+const camel=aliasConfigKey(from);
+out.push({to:camel!==from&&!present.has(camel)?camel:from,from});
+}
+return out;
+}
+function hostAttrs(attrs){
+const out={};
+for(const key of HOST_ATTRS){
+if(attrs&&Object.hasOwn(attrs,key))out[key]=attrs[key];
+}
+return out;
+}
+function watchEachProp(vue,bag,onChange){
+const{watch}=vue;
+const perKey=new Map();
+const options={flush:'post'};
+const sync=()=>{
+const attrs=bag();
+const live=new Set(configKeys(attrs).map((entry)=>entry.from));
+for(const key of live){
+if(perKey.has(key))continue;
+perKey.set(key,watch(()=>bag()[key],onChange,options));
+}
+for(const[key,stop]of[...perKey]){
+if(live.has(key))continue;
+stop();
+perKey.delete(key);
+}
+};
+const keySignature=()=>{
+const attrs=bag();
+void attrs[ATTRS_PROBE];
+return Object.keys(attrs).sort().join('\u0000');
+};
+const stopKeys=watch(
+keySignature,
+()=>{sync();onChange();},
+options,
+);
+sync();
+return()=>{
+stopKeys();
+for(const stop of perKey.values())stop();
+perKey.clear();
+};
+}
+function applyPredicates(grid,next,previous){
+const now=next&&typeof next==='object'?next:{};
+const before=previous&&typeof previous==='object'?previous:{};
+for(const[name,fn]of Object.entries(now)){
+if(Object.is(before[name],fn))continue;
+grid.filters.where(name,typeof fn==='function'?fn:null);
+}
+for(const name of Object.keys(before)){
+if(!Object.hasOwn(now,name))grid.filters.where(name,null);
+}
+}
 function createLatticeGrid(deps){
 const vue=deps&&deps.vue;
 const createGrid=deps&&deps.createGrid;
-if(!vue||typeof vue.h!=='function'){
-throw new TypeError('createLatticeGrid needs the Vue runtime: createLatticeGrid({ vue, createGrid }).');
-}
+requireVue(vue,'createLatticeGrid');
 if(typeof createGrid!=='function'){
 throw new TypeError('createLatticeGrid needs createGrid: createLatticeGrid({ vue, createGrid }).');
 }
-const{h,ref,onMounted,onBeforeUnmount,watchEffect}=vue;
-return{
+const{
+h,ref,shallowRef,onMounted,onBeforeUnmount,
+}=vue;
+const inject=typeof vue.inject==='function'?vue.inject:null;
+return define(vue,{
 name:'LatticeGrid',
-emits:EVENT_NAMES.map(dashedName),
+props:{
+rowUpdates:{type:Object,default:undefined},
+predicates:{type:Object,default:undefined},
+name:{type:String,default:undefined},
+route:{type:null,default:undefined},
+routeOptions:{type:Object,default:undefined},
+},
+emits:[...EVENT_NAMES.map(dashedName),'grid-ready','grid-destroyed'],
 inheritAttrs:false,
 setup(props,ctx){
 const host=ref(null);
-const controller=ref(null);
+const controller=shallowRef(null);
+const registry=inject?inject(GRID_REGISTRY_KEY,null):null;
+const router=inject?inject(ROUTER_KEY,null):null;
+const applied={predicates:undefined};
+let publishedAs=DEFAULT_GRID_NAME;
+let stopWatching=null;
 const gridProps=()=>{
 const out={};
 const attrs=ctx.attrs||{};
-for(const[key,value]of Object.entries(attrs)){
-if(isHandlerProp(key))continue;
-const camel=aliasConfigKey(key);
-if(camel!==key&&!Object.hasOwn(attrs,camel)){
-out[camel]=value;
-}else{
-out[key]=value;
-}
-}
+for(const{to,from}of configKeys(attrs))out[to]=attrs[from];
 for(const name of EVENT_NAMES){
-out[`on${name.split(':').map((p)=>p.charAt(0).toUpperCase()+p.slice(1)).join('')}`]=
+out[handlerName(name)]=
 (event)=>ctx.emit(dashedName(name),event);
 }
 return out;
 };
 onMounted(()=>{
-controller.value=createGridController({
+const live=createGridController({
 createGrid,element:host.value,props:gridProps(),
 });
-watchEffect(()=>{
-const live=controller.value;
-if(live)live.update(gridProps());
+controller.value=live;
+const{grid}=live;
+if(props.predicates){
+applyPredicates(grid,(props.predicates),{});
+applied.predicates=props.predicates;
+}
+publishedAs=typeof props.name==='string'&&props.name?props.name:DEFAULT_GRID_NAME;
+if(registry)registry.publish(publishedAs,grid);
+if(router&&props.route!==undefined){
+router.attach(grid,props.route,props.routeOptions||{});
+}
+ctx.emit('grid-ready',grid);
+stopWatching=watchEachProp(vue,()=>ctx.attrs||{},()=>{
+const held=controller.value;
+if(held)held.update(gridProps());
 });
 });
+{
+vue.watch(()=>props.predicates,(next,before)=>{
+const held=controller.value;
+if(!held)return;
+applyPredicates(held.grid,(next),(before));
+applied.predicates=next;
+},{flush:'post'});
+vue.watch(()=>props.rowUpdates,(next)=>{
+const held=controller.value;
+if(!held||!next)return;
+held.grid.rows.apply(next);
+},{flush:'post'});
+}
 onBeforeUnmount(()=>{
 const live=controller.value;
 controller.value=null;
-if(live)live.destroy();
+if(stopWatching)stopWatching();
+stopWatching=null;
+if(!live)return;
+ctx.emit('grid-destroyed');
+if(router){
+try{router.detach(live.grid);}catch{}
+}
+if(registry)registry.publish(publishedAs,null);
+applied.predicates=undefined;
+live.destroy();
 });
 const grid=()=>(controller.value?controller.value.grid:null);
 if(typeof ctx.expose==='function')ctx.expose({grid});
-return()=>h('div',{ref:host});
+return()=>h('div',{...hostAttrs(ctx.attrs||{}),ref:host});
+},
+});
+}
+function createLatticeGridContext(deps){
+const vue=deps&&deps.vue;
+requireVue(vue,'createLatticeGridContext');
+if(typeof vue.provide!=='function'||typeof vue.inject!=='function'){
+throw new TypeError('createLatticeGridContext needs a Vue with provide and inject.');
+}
+const{
+h,shallowRef,provide,inject,computed,
+}=vue;
+const makeRegistry=()=>{
+const grids=shallowRef({});
+return{
+grids,
+publish(name,grid){
+const key=name||DEFAULT_GRID_NAME;
+const held=grids.value;
+if(Object.is(held[key],grid))return;
+const next={...held};
+if(grid===null||grid===undefined)delete next[key];
+else next[key]=grid;
+grids.value=next;
+},
+};
+};
+const provideLatticeGrids=()=>{
+const registry=makeRegistry();
+provide(GRID_REGISTRY_KEY,registry);
+return registry;
+};
+const LatticeGridProvider=define(vue,{
+name:'LatticeGridProvider',
+setup(props,ctx){
+provideLatticeGrids();
+return()=>(ctx.slots&&ctx.slots.default?ctx.slots.default():null);
+},
+});
+const useLatticeGrid=(name=DEFAULT_GRID_NAME)=>{
+const registry=inject(GRID_REGISTRY_KEY,null);
+const read=()=>(registry?(registry.grids.value[name||DEFAULT_GRID_NAME]??null):null);
+return computed(read);
+};
+return{LatticeGridProvider,provideLatticeGrids,useLatticeGrid};
+}
+function createLatticeViewer(options){
+const vue=options&&options.vue;
+requireVue(vue,'createLatticeViewer');
+const viewer=String((options&&options.viewer)||'');
+const mount=options.mount;
+const label=options.name||`Lattice${viewer.charAt(0).toUpperCase()}${viewer.slice(1)}`;
+const requires=Array.isArray(options.requires)?options.requires:[];
+const fromContext=options.fromContext||null;
+if(typeof mount!=='function'){
+throw new TypeError(`${label} needs a mount factory: createLatticeViewer({ vue, mount }).`);
+}
+if(!Object.hasOwn(VIEWER_EVENTS,viewer)){
+throw new TypeError(
+`createLatticeViewer: "${viewer}" is not a viewer this adapter knows; expected one of `
++`${Object.keys(VIEWER_EVENTS).join(', ')}.`);
+}
+const{
+h,ref,shallowRef,onMounted,onBeforeUnmount,
+}=vue;
+const inject=typeof vue.inject==='function'?vue.inject:null;
+const events=VIEWER_EVENTS[viewer];
+return define(vue,{
+name:label,
+props:{
+grid:{type:null,default:undefined},
+gridName:{type:String,default:undefined},
+},
+emits:[...events.map(dashedName),'ready','destroyed'],
+inheritAttrs:false,
+setup(props,ctx){
+const host=ref(null);
+const controller=shallowRef(null);
+const registry=fromContext&&inject?inject(GRID_REGISTRY_KEY,null):null;
+let stopWatching=null;
+let builtAgainst=null;
+const boundGrid=()=>{
+if(!fromContext)return null;
+if(props.grid!==undefined)return(props.grid);
+if(!registry)return null;
+const key=typeof props.gridName==='string'&&props.gridName
+?props.gridName:DEFAULT_GRID_NAME;
+return registry.grids.value[key]??null;
+};
+const viewerProps=()=>{
+const out={};
+const attrs=ctx.attrs||{};
+for(const{to,from}of configKeys(attrs))out[to]=attrs[from];
+if(fromContext){
+const bound=boundGrid();
+if(bound)out[fromContext]=bound;
+}
+for(const name of events){
+out[viewerHandlerName(name)]=
+(payload)=>ctx.emit(dashedName(name),payload);
+}
+return out;
+};
+const build=()=>{
+if(controller.value||!host.value)return;
+const next=viewerProps();
+if(requires.some((key)=>next[key]===null||next[key]===undefined))return;
+const live=createViewerController({
+viewer,mount,element:host.value,props:next,name:label,
+});
+controller.value=live;
+builtAgainst=fromContext?((next[fromContext])??null):null;
+ctx.emit('ready',live.instance);
+};
+const tearDown=()=>{
+const live=controller.value;
+controller.value=null;
+builtAgainst=null;
+if(!live)return;
+ctx.emit('destroyed');
+live.destroy();
+};
+onMounted(()=>{
+build();
+stopWatching=watchEachProp(vue,()=>ctx.attrs||{},()=>{
+const held=controller.value;
+if(held)held.update(viewerProps());
+else build();
+});
+});
+{
+vue.watch(boundGrid,(next)=>{
+if(controller.value&&Object.is(builtAgainst,next??null))return;
+tearDown();
+build();
+},{flush:'post'});
+}
+onBeforeUnmount(()=>{
+if(stopWatching)stopWatching();
+stopWatching=null;
+tearDown();
+});
+const instance=()=>(controller.value?controller.value.instance:null);
+if(typeof ctx.expose==='function')ctx.expose({instance});
+return()=>h('div',{...hostAttrs(ctx.attrs||{}),ref:host});
+},
+});
+}
+function createLatticeKPI(deps){
+const createKPI=deps&&deps.createKPI;
+if(typeof createKPI!=='function'){
+throw new TypeError('createLatticeKPI needs createKPI: createLatticeKPI({ vue, createKPI }).');
+}
+return createLatticeViewer({
+vue:deps.vue,
+viewer:'kpi',
+name:'LatticeKPI',
+mount:(el,config)=>createKPI(el,config),
+fromContext:'grid',
+});
+}
+function createLatticeChart(deps){
+const createChart=deps&&deps.createChart;
+if(typeof createChart!=='function'){
+throw new TypeError('createLatticeChart needs createChart: createLatticeChart({ vue, createChart }).');
+}
+return createLatticeViewer({
+vue:deps.vue,
+viewer:'chart',
+name:'LatticeChart',
+mount:(el,config)=>createChart({...config,container:el}),
+requires:['grid'],
+fromContext:'grid',
+});
+}
+function createLatticeKanban(deps){
+const createKanban=deps&&deps.createKanban;
+if(typeof createKanban!=='function'){
+throw new TypeError('createLatticeKanban needs createKanban: createLatticeKanban({ vue, createKanban }).');
+}
+return createLatticeViewer({
+vue:deps.vue,
+viewer:'kanban',
+name:'LatticeKanban',
+mount:(el,config)=>createKanban(el,config),
+fromContext:'grid',
+});
+}
+function createLatticeGantt(deps){
+const createGantt=deps&&deps.createGantt;
+if(typeof createGantt!=='function'){
+throw new TypeError('createLatticeGantt needs createGantt: createLatticeGantt({ vue, createGantt }).');
+}
+return createLatticeViewer({
+vue:deps.vue,
+viewer:'gantt',
+name:'LatticeGantt',
+mount:(el,config)=>createGantt({...config,element:el}),
+});
+}
+function createLatticeLayout(deps){
+const createLayout=deps&&deps.createLayout;
+if(typeof createLayout!=='function'){
+throw new TypeError('createLatticeLayout needs createLayout: createLatticeLayout({ vue, createLayout }).');
+}
+return createLatticeViewer({
+vue:deps.vue,
+viewer:'layout',
+name:'LatticeLayout',
+mount:(el,config)=>createLayout(el,config),
+});
+}
+function tabSlotNames(id){
+return[String(id),`tab-${String(id)}`];
+}
+function createLatticeTabs(deps){
+const vue=deps&&deps.vue;
+const createTabs=deps&&deps.createTabs;
+requireVue(vue,'createLatticeTabs');
+if(typeof createTabs!=='function'){
+throw new TypeError('createLatticeTabs needs createTabs: createLatticeTabs({ vue, createTabs }).');
+}
+if(!vue.Teleport){
+throw new TypeError('createLatticeTabs needs a Vue with Teleport, which is how a tab\'s slot reaches the strip\'s panel.');
+}
+const{
+h,ref,shallowRef,Teleport,Fragment,onMounted,onBeforeUnmount,
+}=vue;
+return define(vue,{
+name:'LatticeTabs',
+props:{
+tabs:{type:Array,default:()=>[]},
+active:{type:String,default:undefined},
+},
+emits:[...VIEWER_EVENTS.tabs.map(dashedName),'ready','destroyed'],
+inheritAttrs:false,
+setup(props,ctx){
+const host=ref(null);
+const strip=shallowRef(null);
+const panels=shallowRef({});
+const off=[];
+let appliedTabs=null;
+const slotFor=(id)=>{
+const slots=ctx.slots||{};
+for(const name of tabSlotNames(id)){
+if(typeof slots[name]==='function')return slots[name];
+}
+return null;
+};
+onMounted(()=>{
+const config={};
+const attrs=ctx.attrs||{};
+for(const{to,from}of configKeys(attrs))config[to]=attrs[from];
+const declared=Array.isArray(props.tabs)?props.tabs:[];
+const descriptors=declared.map((tab)=>{
+const spec=(tab);
+if(!slotFor(spec.id))return spec;
+return{
+...spec,
+view:(bodyEl)=>{
+panels.value={...panels.value,[spec.id]:bodyEl};
+return{
+destroy(){
+if(!Object.hasOwn(panels.value,spec.id))return;
+const next={...panels.value};
+delete next[spec.id];
+panels.value=next;
+},
+};
+},
+};
+});
+const live=createTabs(host.value,{
+...config,
+tabs:descriptors,
+createGrid:deps.createGrid||(()=>{
+throw new Error(
+'[lattice] LatticeTabs: a tab has neither a slot nor a `createGrid` to build it '
++'with. Give the tab a <template #‹id›> slot, or pass createGrid into '
++'createLatticeTabs.');
+}),
+...(typeof props.active==='string'?{active:props.active}:{}),
+});
+strip.value=live;
+appliedTabs=props.tabs;
+for(const event of VIEWER_EVENTS.tabs){
+const stop=live.on(event,(payload)=>ctx.emit(dashedName(event),payload));
+if(typeof stop==='function')off.push(stop);
+}
+ctx.emit('ready',live);
+});
+{
+vue.watch(()=>props.active,(wanted)=>{
+const live=strip.value;
+if(live&&typeof wanted==='string'&&live.activeId!==wanted)live.activate(wanted);
+},{flush:'post'});
+vue.watch(()=>props.tabs,(next)=>{
+if(!strip.value||Object.is(appliedTabs,next))return;
+appliedTabs=next;
+warnOnce('vue.tabs.mountOnly.tabs',
+'LatticeTabs: `tabs` changed (a label, a badge or a descriptor), but the strip takes '
++'it only when created — the module has no way to repaint an existing tab. Nothing '
++'was applied and the strip was NOT rebuilt — rebuilding it would lose whichever tab '
++'is open and any state its content holds. Give the component a `key` that changes '
++'when a genuine rebuild is wanted; a live badge otherwise needs to live in your own '
++'render.');
+},{flush:'post'});
+}
+onBeforeUnmount(()=>{
+const live=strip.value;
+strip.value=null;
+for(const stop of off){
+try{stop();}catch{}
+}
+off.length=0;
+if(!live)return;
+ctx.emit('destroyed');
+live.destroy();
+panels.value={};
+});
+const instance=()=>strip.value;
+if(typeof ctx.expose==='function')ctx.expose({instance,tabs:instance});
+return()=>{
+const children=[h('div',{...hostAttrs(ctx.attrs||{}),ref:host})];
+for(const tab of(Array.isArray(props.tabs)?props.tabs:[])){
+const spec=(tab);
+const target=panels.value[spec.id];
+const slot=slotFor(spec.id);
+if(!target||!slot)continue;
+children.push(h(Teleport,{to:target,key:spec.id},slot()));
+}
+return h(Fragment,null,children);
+};
+},
+});
+}
+function createLatticeRouter(deps){
+const vue=deps&&deps.vue;
+const createDataRouter=deps&&deps.createDataRouter;
+requireVue(vue,'createLatticeRouter');
+if(typeof vue.provide!=='function'||typeof vue.inject!=='function'){
+throw new TypeError('createLatticeRouter needs a Vue with provide and inject.');
+}
+if(typeof createDataRouter!=='function'){
+throw new TypeError(
+'createLatticeRouter needs createDataRouter: createLatticeRouter({ vue, createDataRouter }).');
+}
+const{provide,inject}=vue;
+const provideLatticeRouter=(config)=>{
+let instance=null;
+let torn=false;
+const handle={
+get router(){
+if(!instance&&!torn)instance=createDataRouter(config||{});
+return instance;
+},
+attach(grid,route,opts){
+if(torn)return;
+handle.router.attach(grid,route,opts||{});
+},
+detach(grid){
+if(torn||!instance)return;
+instance.detach(grid);
+},
+destroy(){
+torn=true;
+const live=instance;
+instance=null;
+if(live)live.destroy();
 },
 };
+provide(ROUTER_KEY,handle);
+vue.onScopeDispose(()=>handle.destroy());
+return handle;
+};
+const useLatticeRouter=()=>inject(ROUTER_KEY,null);
+const LatticeRouterProvider=define(vue,{
+name:'LatticeRouterProvider',
+props:{
+config:{type:Object,default:()=>({})},
+},
+setup(props,ctx){
+provideLatticeRouter(props.config);
+return()=>(ctx.slots&&ctx.slots.default?ctx.slots.default():null);
+},
+});
+return{provideLatticeRouter,useLatticeRouter,LatticeRouterProvider};
+}
+function createLatticeVue(deps){
+const vue=deps&&deps.vue;
+requireVue(vue,'createLatticeVue');
+const{
+LatticeGridProvider,provideLatticeGrids,useLatticeGrid,
+}=createLatticeGridContext({vue});
+const out={LatticeGridProvider,provideLatticeGrids,useLatticeGrid};
+if(typeof deps.createGrid==='function'){
+out.LatticeGrid=createLatticeGrid({vue,createGrid:deps.createGrid});
+}
+if(typeof deps.createKPI==='function'){
+out.LatticeKPI=createLatticeKPI({vue,createKPI:deps.createKPI});
+}
+if(typeof deps.createChart==='function'){
+out.LatticeChart=createLatticeChart({vue,createChart:deps.createChart});
+}
+if(typeof deps.createKanban==='function'){
+out.LatticeKanban=createLatticeKanban({vue,createKanban:deps.createKanban});
+}
+if(typeof deps.createGantt==='function'){
+out.LatticeGantt=createLatticeGantt({vue,createGantt:deps.createGantt});
+}
+if(typeof deps.createLayout==='function'){
+out.LatticeLayout=createLatticeLayout({vue,createLayout:deps.createLayout});
+}
+if(typeof deps.createTabs==='function'){
+out.LatticeTabs=createLatticeTabs({
+vue,createTabs:deps.createTabs,createGrid:deps.createGrid,
+});
+}
+if(typeof deps.createDataRouter==='function'){
+Object.assign(out,createLatticeRouter({vue,createDataRouter:deps.createDataRouter}));
+}
+return out;
 }
 const __default=createLatticeGrid;
 });