@swiftwc/ui 0.0.0-dev.3 → 0.0.0-dev.31

package/generated/components/tab-item.js

@@ -0,0 +1,125 @@
+import { CleanupRegistry } from '../internal/class/cleanup-registry';
+import { onoff } from '../internal/utils';
+import { ButtonBase } from '../namespace-browser/base';
+import { TabView } from './tab-view';
+export class TabItem extends ButtonBase {
+    constructor() {
+        super();
+    }
+    static polyfillDisconnectedCallback(btn) {
+        console.debug(`${TabItem.name} ⚡️ disconnect`);
+        CleanupRegistry.unregister(btn);
+    }
+    static polyfillConnectedCallback(btn) {
+        console.debug(`${TabItem.name} ⚡️ connect`);
+        Object.assign(btn, {
+            tabIndex: 0,
+            ariaSelected: 'false',
+        });
+        CleanupRegistry.register(btn, onoff('click', TabItem.#handleClick, btn).on());
+        const handler1 = TabItem.#handleTabRevealOrSwap.bind(null, btn), handler2 = TabItem.#handleTabMoreStackAllowance.bind(null, btn), tv = btn.closest('tab-view') ?? undefined;
+        CleanupRegistry.register(btn, onoff('tabreveal tabswap', handler1, tv).on());
+        CleanupRegistry.register(btn, onoff('tab-view:adaptable-tab-bar-placement-change', handler2, tv).on());
+        // NOTE: Make sure before invoking props of TAB-VIEW
+        self.customElements.whenDefined('tab-view').then(() => {
+            if (!btn.isConnected)
+                return;
+            if (tv?.selectedTab?.map(({ id }) => id)?.includes(btn.value))
+                void this.#handleTabRevealOrSwap(btn, new CustomEvent('tabreveal', { detail: { tag: btn.value } }));
+            if (tv?.moreTab)
+                this.#handleTabMoreStackAllowance(btn, new CustomEvent('tab-view:adaptable-tab-bar-placement-change'));
+        });
+    }
+    static #handleTabMoreStackAllowance = async (btn, evt) => {
+        console.debug(`${TabItem.name} ⚡️ ${evt?.type}`);
+        const tv = btn.closest('tab-view');
+        if (!tv)
+            return;
+        if (tv.moreTab?.id !== btn.value)
+            return;
+        btn.hidden = 'bottom-bar' !== tv.tabBarPlacement;
+    };
+    static #handleTabRevealOrSwap = async (btn, evt) => {
+        console.debug(`${TabItem.name} ⚡️ ${evt?.type}`);
+        const tv = btn?.closest('tab-view');
+        if (!tv)
+            return;
+        // if (evt.detail?.tag !== btn.value) return
+        // await Snapshot.waitReady
+        const isSelected = tv.selectedTab.map(({ id }) => id).includes(btn.value); //'tabreveal' === evt?.type
+        if (`${isSelected}` !== btn.ariaSelected)
+            btn.ariaSelected = `${isSelected}`;
+        if (!isSelected)
+            return;
+        setTimeout(() => {
+            if (btn.ariaSelected !== 'true' || !btn.isConnected)
+                return;
+            btn.scrollIntoView({
+                behavior: self.matchMedia('(prefers-reduced-motion: no-preference)').matches ? 'smooth' : 'instant',
+                block: 'nearest',
+                inline: 'nearest',
+            });
+        }, 100);
+    };
+    static #handleClick = async (evt) => {
+        console.debug(`${TabItem.name} ⚡️ ${evt?.type}`);
+        const btn = evt.currentTarget instanceof HTMLElement && evt.currentTarget;
+        if (!btn)
+            return;
+        // const tag = btn.getAttribute('value')
+        // if (!tag) return // sidebartoggle > tab-item //throw new DOMException(`Attribute "tag" is set but invalid`, 'InvalidStateError')
+        const tv = btn.closest('tab-view');
+        if (!tv)
+            throw new Error('TabView not found');
+        const newTab = tv?.querySelector(`#${btn.getAttribute('value')}`);
+        if (!newTab)
+            return;
+        // console.log(99, TabView.gatherTab(newTab))
+        // const possibleParentNs = newTab?.parentElement?.closest<NavigationStack | NavigationSplitView>('navigation-stack,navigation-split-view')
+        const tabs = TabView.gatherTab(newTab); //[possibleParentNs, newTab].filter(Boolean) as (NavigationStack | NavigationSplitView)[]
+        // if (possibleParentNs) tabs.unshift(possibleParentNs)
+        // SECTION: before submitting new tabs, check for tabroot
+        // iphone cases:
+        // current -> new
+        // ns1 -> ns1 tabroot💡ns1       1 1 ===                            ===
+        // more -> more tabroot💡more    1 1 ===                            ===
+        // ns1 -> more tabroot💡more     1 1 !==                            ->
+        // more,settings -> more tabroot💡more  2 1 !==                     ↖
+        // more,settings -> ns1          2 1 !==                            <-
+        // ns1 -> more tabroot💡more     1 1 !==                            ->
+        // ipad cases:
+        // ns1 -> ns1 tabroot💡ns1                            1 1 ===       ===
+        // more,settings -> more,settings tabroot💡settings   2 2 ===       ===
+        // more,settings -> more,ns3  2 2 !==                               <->
+        // more,ns3 -> more,settings  2 2 !==                               <->
+        // ns1 -> more,settings       1 2 !==                               ↘
+        const seed1 = tv.selectedTab.map((item) => item.id).join(','), seed2 = tabs.map((item) => item.id).join(',');
+        const dir = tv.selectedTab.length < tabs.length
+            ? '↘'
+            : tv.selectedTab.length > tabs.length
+                ? tv.selectedTab.at(0) === tabs.at(0)
+                    ? '↖'
+                    : '<-'
+                : seed1 === seed2
+                    ? '==='
+                    : tv.moreTab === tabs.at(-1)
+                        ? '->'
+                        : '<->';
+        if (['===', '↖'].includes(dir)) {
+            for (const tab of tabs.reverse())
+                if (tv.selectedTab.includes(tab)) {
+                    const eventType = 'tabroot';
+                    console.debug(`${TabItem.name} 💡 ${eventType}`);
+                    tab?.dispatchEvent(new CustomEvent(eventType, { bubbles: true, composed: true }));
+                    return; // skip rest no selection!
+                }
+        }
+        else if ('->' === dir) {
+            const eventType = 'tabroot';
+            console.debug(`${TabItem.name} 💡 ${eventType}`);
+            tabs.at(0)?.dispatchEvent(new CustomEvent(eventType, { bubbles: true, composed: true }));
+        }
+        // SECTION: finally, submit new tabs
+        tv.selectedTab = tabs;
+    };
+}

package/generated/components/tab-view.d.ts

@@ -0,0 +1,22 @@
+import { type NavigationSplitView } from './navigation-split-view';
+import { type NavigationStack } from './navigation-stack';
+declare const TAB_BAR_PLACEMENTS: readonly ["bottom-bar", "ornament", "sidebar", "top-bar"];
+export type TabBarPlacement = (typeof TAB_BAR_PLACEMENTS)[number];
+/**
+ * @fires tabshow A Tab is shown
+ * @fires tabhide A Tab is hidden
+ * @fires tab-view:toggle
+ * @fires tab-view:adaptable-tab-bar-placement-change
+ */
+export declare class TabView extends HTMLElement {
+    #private;
+    static gatherTab(newTab: NavigationStack | NavigationSplitView): (NavigationStack | NavigationSplitView)[];
+    constructor();
+    disconnectedCallback(): void;
+    get tabBarPlacement(): "bottom-bar" | "ornament" | "sidebar" | "top-bar" | undefined;
+    get moreTab(): NavigationStack | null;
+    connectedCallback(): void;
+    get selectedTab(): (NavigationStack | NavigationSplitView)[];
+    set selectedTab(tabs: (NavigationStack | NavigationSplitView)[]);
+}
+export {};

package/generated/components/tab-view.js

@@ -0,0 +1,259 @@
+var _a;
+import { CleanupRegistry } from '../internal/class/cleanup-registry';
+import { CSSStyleObserver } from '../internal/class/css-style-observer';
+import { NavigationPath } from '../internal/class/navigation-path';
+import { $, cssTime, debounce, frame, onoff, timeout } from '../internal/utils';
+import { Snapshot } from '../snapshot';
+const TAB_BAR_PLACEMENTS = ['bottom-bar', 'ornament', 'sidebar', 'top-bar'];
+/**
+ * @fires tabshow A Tab is shown
+ * @fires tabhide A Tab is hidden
+ * @fires tab-view:toggle
+ * @fires tab-view:adaptable-tab-bar-placement-change
+ */
+export class TabView extends HTMLElement {
+    #debouncedHandler;
+    #cssStyleObserver;
+    #afterTabRevealDelay = timeout();
+    #cachedAdaptableTabBarPlacement = 'bottom-bar';
+    static gatherTab(newTab) {
+        const possibleParentNs = newTab?.parentElement?.closest('navigation-stack,navigation-split-view');
+        return [possibleParentNs, newTab].filter(Boolean);
+    }
+    constructor() {
+        super();
+        this.#debouncedHandler = debounce(this.#handleSelectionChange, 1);
+    }
+    disconnectedCallback() {
+        console.debug(`${_a.name} ⚡️ disconnect`);
+        this.#afterTabRevealDelay.cancel();
+        this.#cssStyleObserver?.disconnect();
+        CleanupRegistry.unregister(this);
+    }
+    get tabBarPlacement() {
+        return this.#cachedAdaptableTabBarPlacement;
+    }
+    get moreTab() {
+        return this.querySelector(':scope>navigation-stack:has(> navigation-stack,> navigation-split-view)');
+    }
+    connectedCallback() {
+        console.debug(`${_a.name} ⚡️ connect`);
+        this.#cssStyleObserver = new CSSStyleObserver({
+            properties: ['--adaptable-tab-bar-placement-index'],
+        });
+        this.#cssStyleObserver.observe(this, this.#handleStyleChange);
+        Snapshot.waitReady.then(() => self.requestAnimationFrame(this.#handleStyleChange)); // Snapshot.waitReady.then(this.#handleStyleChange)
+        // NOTE: wait for config
+        // Snapshot.waitReady.then(() => { // FIXME: Check this removed!
+        // for (const [or, w, handler] of [
+        //   ['portrait', `max-width:${Snapshot.config!['ipad-portrait-bp-max']}`, this.#handleMediaChange],
+        //   ['landscape', `max-width:${Snapshot.config!['ipad-landscape-bp-max']}`, this.#handleMediaChange],
+        //   ['portrait', `min-width:${Snapshot.config!['ipad-portrait-bp-min']}`, this.#handleMediaChange],
+        //   ['landscape', `min-width:${Snapshot.config!['ipad-landscape-bp-min']}`, this.#handleMediaChange],
+        // ]) {
+        //   const mediaQueryList = self.matchMedia(`(orientation:${or}) and (${w})`)
+        //   if (mediaQueryList.matches)
+        //     this.#handleMediaChange(
+        //       new MediaQueryListEvent('media-change', {
+        //         matches: mediaQueryList.matches,
+        //       })
+        //     ) // Initial check
+        //   CleanupRegistry.register(this, onoff('change', handler as EventListener, mediaQueryList).on())
+        // }
+        CleanupRegistry.register(this, onoff([
+            { types: 'tabreveal tabswap', listener: this.#debouncedHandler },
+            { types: 'beforetabreveal beforetabswap', listener: this.#addAnimations },
+            { types: 'tab-view:adaptable-tab-bar-placement-change', listener: this.#handleAdaptableTabBarPlacementChange },
+            { types: 'pagereveal', listener: this.#handleTabViewPagereveal },
+            {
+                types: 'click',
+                listener: this.#handleSummaryClick,
+            },
+        ], this).on());
+        // })
+    }
+    #handleSummaryClick = (evt) => {
+        const target = evt.target instanceof HTMLElement && evt.target;
+        if (!target)
+            return;
+        const summary = target.closest('summary');
+        if (!summary)
+            return;
+        if (0 === $.siblings('[aria-selected=true]', summary).length)
+            return;
+        if (!summary.closest('scroll-view')?.matches('tab-view > [is=sidebar-view] > scroll-view'))
+            return;
+        const form = summary.closest('[is=form-view]');
+        if (!form)
+            return;
+        const style = self.getComputedStyle(form);
+        if ('sidebar' !== style.getPropertyValue('--list-style'))
+            return;
+        this.#addAnimations(new CustomEvent('beforetabreveal', { detail: { tag: '', ms: cssTime(`${this.computedStyleMap().get(`--tabbar-after-tabreveal-duration`)}`) }, bubbles: true, composed: true }));
+    };
+    #handleTabViewPagereveal = (evt) => {
+        console.debug(`${_a.name} ⚡️ ${evt?.type}`);
+        void this.#syncBodyFace();
+    };
+    #handleStyleChange = () => {
+        console.debug(`${_a.name} ⚡️ style`);
+        const style = self.getComputedStyle(this);
+        const placement = style.getPropertyValue('--adaptable-tab-bar-placement'), // or do it manually without any computedstyle
+        newValue = TAB_BAR_PLACEMENTS.includes(placement) ? placement : 'bottom-bar';
+        if (newValue !== this.#cachedAdaptableTabBarPlacement) {
+            const oldValue = this.#cachedAdaptableTabBarPlacement;
+            this.#cachedAdaptableTabBarPlacement = newValue;
+            this.dispatchEvent(new CustomEvent('tab-view:adaptable-tab-bar-placement-change', {
+                detail: { oldValue, newValue },
+                bubbles: true,
+                composed: true,
+            }));
+        }
+    };
+    // #handleMediaChange: (evt: MediaQueryListEvent) => void = (evt) => {
+    //   console.debug(`${TabView.name} ⚡️ ${evt?.type}`)
+    //   if (!evt.matches) return
+    //   this.#handleStyleChange()
+    //   // if (evt.matches) {
+    //   //   const placement = self.getComputedStyle(this).getPropertyValue('--adaptable-tab-bar-placement'), // or do it manually without any computedstyle
+    //   //     newValue = (TAB_BAR_PLACEMENTS as readonly string[]).includes(placement) ? (placement as (typeof TAB_BAR_PLACEMENTS)[number]) : 'bottom-bar'
+    //   //   if (newValue !== this.#cachedAdaptableTabBarPlacement) {
+    //   //     const oldValue = this.#cachedAdaptableTabBarPlacement
+    //   //     this.#cachedAdaptableTabBarPlacement = newValue
+    //   //     this.dispatchEvent(
+    //   //       new CustomEvent<TabViewAdaptableTabBarPlacementDetail>('tab-view:adaptable-tab-bar-placement-change', {
+    //   //         detail: { oldValue, newValue },
+    //   //         bubbles: true,
+    //   //         composed: true,
+    //   //       })
+    //   //     )
+    //   //   }
+    //   // }
+    //   // // trigger more-stack (dis)allowed event
+    //   // if (evt.matches !== this.#moreStackAllowed) {
+    //   //   this.#moreStackAllowed = evt.matches
+    //   //   const eventType = evt.matches ? 'tab-view:more-tab-allowed' : 'tab-view:more-tab-disallowed'
+    //   //   this.dispatchEvent(new CustomEvent<TabMoreStackAllowanceDetail>(eventType, { detail: { moreTab: this.moreTab }, bubbles: true, composed: true }))
+    //   // }
+    //   // if (evt.matches) return // no button triggers should happen, already on iphone portrait
+    //   // const innerSelection = this.moreTab?.querySelector(':scope>navigation-stack:not([hidden]),:scope>navigation-split-view:not([hidden])')?.id
+    //   // if (innerSelection) {
+    //   //   const btn = this.querySelector<HTMLButtonElement>(`[is="tab-item"][value="${CSS.escape(innerSelection)}"]`)
+    //   //   // NOTE: simulate btn click BU WITHOUT tabroot functionality!
+    //   //   if (btn) {
+    //   //     const newTab = this.querySelector<NavigationStack | NavigationSplitView>(`#${btn.getAttribute('value')}`)
+    //   //     if (newTab) {
+    //   //       this.selectedTab = TabView.gatherTab(newTab)
+    //   //       return
+    //   //     }
+    //   //   }
+    //   // }
+    //   // const outerSelection = this?.querySelector(':scope>navigation-stack:not([hidden]),:scope>navigation-split-view:not([hidden])')?.id
+    //   // if (outerSelection && outerSelection === this.moreTab?.id) {
+    //   //   const btn = this.querySelector<HTMLButtonElement>(`[is="tab-item"]:not([value="${CSS.escape(outerSelection)}"])`)
+    //   //   // NOTE: simulate btn click BU WITHOUT tabroot functionality!
+    //   //   if (btn) {
+    //   //     const newTab = this.querySelector<NavigationStack | NavigationSplitView>(`#${btn.getAttribute('value')}`)
+    //   //     if (newTab) {
+    //   //       this.selectedTab = TabView.gatherTab(newTab)
+    //   //       return
+    //   //     }
+    //   //   }
+    //   // }
+    // }
+    #handleAdaptableTabBarPlacementChange = (evt) => {
+        console.debug(`${_a.name} ⚡️ ${evt?.type}`);
+        if ('bottom-bar' !== evt.detail.oldValue)
+            return; // button triggers should happen, ONLY when going FROM bottom-bar TO anything else
+        const innerSelection = this.moreTab?.querySelector(':scope>navigation-stack:not([hidden]),:scope>navigation-split-view:not([hidden])')?.id;
+        if (innerSelection) {
+            const btn = this.querySelector(`[is="tab-item"][value="${CSS.escape(innerSelection)}"]`);
+            // NOTE: simulate btn click BU WITHOUT tabroot functionality!
+            if (btn) {
+                const newTab = this.querySelector(`#${btn.getAttribute('value')}`);
+                if (newTab) {
+                    this.selectedTab = _a.gatherTab(newTab);
+                    return;
+                }
+            }
+        }
+        const outerSelection = this?.querySelector(':scope>navigation-stack:not([hidden]),:scope>navigation-split-view:not([hidden])')?.id;
+        if (outerSelection && outerSelection === this.moreTab?.id) {
+            const btn = this.querySelector(`[is="tab-item"]:not([value="${CSS.escape(outerSelection)}"])`);
+            // NOTE: simulate btn click BU WITHOUT tabroot functionality!
+            if (btn) {
+                const newTab = this.querySelector(`#${btn.getAttribute('value')}`);
+                if (newTab) {
+                    this.selectedTab = _a.gatherTab(newTab);
+                    return;
+                }
+            }
+        }
+    };
+    get selectedTab() {
+        // return this.querySelector<NavigationStack | NavigationSplitView>(':scope>navigation-stack:not([hidden]),:scope>navigation-split-view:not([hidden])')
+        return [...this.querySelectorAll('navigation-stack:not([hidden]),navigation-split-view:not([hidden])')];
+    }
+    set selectedTab(tabs) {
+        const valid = [...tabs].every((el, i, arr) => !i || arr[i - 1].contains(el));
+        if (0 === tabs.length)
+            throw new Error('Element not found');
+        if (!valid)
+            throw new Error('selectedTab[] must be in order of parent>child. You provided an element that contains the previous sibling.');
+        //
+        const selectors = [':not(:is(:scope>{{tag}}))', ':is(:scope>{{tag}})']; // first nested ones, then root ones
+        const ms = cssTime(`${this.computedStyleMap().get(`--tabbar-after-tabreveal-duration`)}`);
+        for (const selector of selectors)
+            for (const ns of this.querySelectorAll(`navigation-stack:not([hidden])${selector.replace('{{tag}}', 'navigation-stack')},navigation-split-view:not([hidden])${selector.replace('{{tag}}', 'navigation-split-view')}`)) {
+                if (!tabs.some((tab) => !ns.contains(tab)))
+                    continue; // shouldRun
+                ns.dispatchEvent(new CustomEvent('beforetabswap', { detail: { tag: ns.id, ms }, bubbles: true, composed: true }));
+                ns.hidden = true; // triggers
+            }
+        for (const selector of selectors.reverse())
+            for (const ns of this.querySelectorAll(`navigation-stack[hidden]${selector.replace('{{tag}}', 'navigation-stack')},navigation-split-view[hidden]${selector.replace('{{tag}}', 'navigation-split-view')}`)) {
+                if (!tabs.some((tab) => ns.contains(tab)))
+                    continue; // shouldRun
+                ns.dispatchEvent(new CustomEvent('beforetabreveal', { detail: { tag: ns.id, ms }, bubbles: true, composed: true }));
+                ns.hidden = false; // triggers
+            }
+    }
+    #addAnimations = (evt) => {
+        this.setAttribute('js-aftertabreveal', '');
+        // const ms = cssTime(`${this.computedStyleMap().get(`--tabbar-after-tabreveal-duration`)}`)
+        this.#afterTabRevealDelay.next(() => {
+            this.removeAttribute('js-aftertabreveal');
+        }, evt.detail.ms);
+    };
+    #handleSelectionChange = (evt) => {
+        this.#triggerToggleEvent(evt);
+    };
+    #triggerToggleEvent = (evt) => {
+        const eventType = 'tab-view:toggle';
+        void this.#syncBodyFace();
+        console.debug(`${_a.name} 💡 ${eventType}`);
+        this.dispatchEvent(new CustomEvent(eventType, { detail: { selection: this.selectedTab }, bubbles: true, composed: true }));
+    };
+    #syncBodyFace = async () => {
+        if (!(await frame(this)))
+            return;
+        const tab = this.selectedTab.at(-1), //event.detail.selection.at(-1), //document.querySelector(`#${}`),
+        path = new NavigationPath(tab), sv = [path, ...path.children()]
+            .filter((item) => item.component?.matches(':not(dialog)'))
+            .map((item) => item.body)
+            .filter(Boolean)
+            .at(-1); //queryBodyAll(tab).at(-1)
+        if (!sv)
+            return;
+        // const style = self.getComputedStyle(sv),
+        //   hostStyle = self.getComputedStyle(document.documentElement)
+        // console.log(999, tab, style.getPropertyValue('--face'), hostStyle.getPropertyValue('--face'))
+        if (!sv.style.getPropertyValue('--face'))
+            return document.body.style.removeProperty('--face');
+        // if (style.getPropertyValue('--face') === hostStyle.getPropertyValue('--face'))
+        document.body.style.setProperty('--face', sv.style.getPropertyValue('--face'));
+        // if (tab?.matches('tab-view>navigation-stack>:scope')) return document.body.style.setProperty('--face', style.getPropertyValue('--face'))
+        // if (tab?.matches('tab-view>:scope')) return document.body.style.setProperty('--face', style.getPropertyValue('--face'))
+    };
+}
+_a = TabView;

package/generated/components/table-view.d.ts

@@ -0,0 +1,7 @@
+export declare class TableView extends HTMLElement {
+    #private;
+    static get template(): DocumentFragment;
+    constructor();
+    disconnectedCallback(): void;
+    connectedCallback(): void;
+}

package/generated/components/table-view.js

@@ -0,0 +1,187 @@
+var _a;
+import { CleanupRegistry } from '../internal/class/cleanup-registry';
+import { CSSStyleObserver } from '../internal/class/css-style-observer';
+import { MutationObserverSingleton } from '../internal/class/mutation-observer-singleton';
+import { $, listActive, onoff } from '../internal/utils';
+import { Snapshot } from '../snapshot';
+const observers = new MutationObserverSingleton();
+export class TableView extends HTMLElement {
+    #styleObserver;
+    #compactToolbarItem;
+    #trackedElements = new Set();
+    static #template;
+    static get template() {
+        return (this.#template ??= $(String.raw `
+    <div part="root table-container">
+      <div part="root table-header-stack">
+        <div part="root table-header-leading-stack">
+          <slot name="header-leading"></slot>
+        </div>
+        <div part="root table-header-principal-stack">
+          <slot name="header-principal"></slot>
+        </div>
+        <div part="root table-header-trailing-stack">
+          <slot name="header-trailing"></slot>
+        </div>
+      </div>
+      <div part="root table-column-stack">
+        <slot name="column"></slot>
+      </div>
+      <slot><p>empty</p></slot>
+      <div part="root table-footer-stack">
+        <div part="root table-footer-leading-stack">
+          <slot name="footer-leading"></slot>
+        </div>
+        <div part="root table-footer-principal-stack">
+          <slot name="footer-principal"></slot>
+        </div>
+        <div part="root table-footer-trailing-stack">
+          <slot name="footer-trailing"></slot>
+        </div>
+      </div>
+    </div>`));
+    }
+    #shadowRoot;
+    #slots = new Map();
+    // #colSlot?: HTMLSlotElement
+    // #slot?: HTMLSlotElement
+    constructor() {
+        super();
+        this.#shadowRoot = this.attachShadow({ mode: 'closed' });
+        this.#shadowRoot.appendChild(document.importNode(this.constructor.template, true));
+        for (const slot of this.#shadowRoot.querySelectorAll('slot'))
+            this.#slots?.set(slot.name, slot);
+        CleanupRegistry.register(this, () => {
+            this.#slots = new Map();
+        });
+        // this.#colSlot = this.#shadowRoot.querySelector<HTMLSlotElement>('slot[name=column]') ?? undefined
+        // this.#slot = this.#shadowRoot.querySelector<HTMLSlotElement>('slot:not([name])') ?? undefined
+        this.#slots?.get('column')?.addEventListener('slotchange', this.#handleSlotchange);
+        // this.append(
+        //   document.createRange().createContextualFragment(`<menu-view slot="header-trailing">
+        //               <label-view slot="label" title="Delete"></label-view>
+        //               <button type="button" tabindex="0">
+        //                 <label-view system-image="dots-three" title="Scan Documents"></label-view>
+        //               </button>
+        //               <button type="button" tabindex="0">
+        //                 <label-view system-image="dots-three" title="Connect to Server"></label-view>
+        //               </button>
+        //               <button type="button" tabindex="0">
+        //                 <label-view title="Edit Sidebar"></label-view>
+        //               </button>
+        //             </menu-view>
+        //             `)
+        // $(`<menu-view slot="header-trailing">
+        //             <label-view slot="label" title="Delete"></label-view>
+        //             <button type="button" tabindex="0">
+        //               <label-view system-image="dots-three" title="Scan Documents"></label-view>
+        //             </button>
+        //             <button type="button" tabindex="0">
+        //               <label-view system-image="dots-three" title="Connect to Server"></label-view>
+        //             </button>
+        //             <button type="button" tabindex="0">
+        //               <label-view title="Edit Sidebar"></label-view>
+        //             </button>
+        //           </menu-view>
+        //           <div slot="footer-leading">22</div>
+        //           <div slot="footer-trailing"><button>&lt;</button> <button>&gt;</button></div>`)
+        // )
+    }
+    disconnectedCallback() {
+        console.debug(`${_a.name} ⚡️ disconnect`);
+        CleanupRegistry.unregister(this);
+        this.#styleObserver?.disconnect();
+        observers.clearObservationsSet(this.#trackedElements);
+        this.#compactToolbarItem = undefined;
+    }
+    connectedCallback() {
+        console.debug(`${_a.name} ⚡️ connect`);
+        CleanupRegistry.register(this, onoff(listActive(this), this).on());
+        // console.log(999, this.#shadowRoot.querySelector('[part*=table-column-stack]'))
+        this.#styleObserver = new CSSStyleObserver({
+            properties: ['--adaptable-table-style-index'],
+        });
+        const target = this.#shadowRoot.querySelector('[part*=table-container]') ?? undefined;
+        if (!target)
+            return;
+        this.#styleObserver.observe(target, this.#handleStyleChange);
+        Snapshot.waitReady.then(() => self.requestAnimationFrame(this.#handleStyleChange));
+    }
+    #handleSlotchange = (evt) => {
+        console.debug(`${_a.name} ⚡️ ${evt?.type}`);
+        const slot = evt.target instanceof HTMLSlotElement && evt.target;
+        if (!slot)
+            return;
+        const assigned = slot.assignedElements({ flatten: true });
+        observers.syncObservations(this.#trackedElements, assigned, this.#handleTagMutation);
+        if (0 < assigned.length)
+            this.#handleTagMutation();
+    };
+    #handleTagMutation = (entry) => {
+        console.debug(`${_a.name} ⚡️ mutation`);
+        // const sourceSlot = 0 < (this.#slots?.get('column')?.assignedElements({ flatten: true }) ?? []).length ? this.#slots?.get('column') : this.#slots?.get('column')
+        // const menu = this.querySelector(':scope>menu-view:not([slot])') ?? this.appendChild($(`<menu-view></menu-view>`))
+        // menu.innerHTML = `<label-view slot="label" system-image="dots-three" title="rtyty"></label-view>`
+        // for (const el of sourceSlot?.assignedElements({ flatten: true }) ?? []) menu.insertAdjacentElement('beforeend', TableView.wrapTag(el, sourceSlot?.name))
+        //
+        if (!this.#compactToolbarItem) {
+            this.#compactToolbarItem = $(`<menu-view tabindex="0" slot="header-trailing"></menu-view>`, '>1');
+            CleanupRegistry.unregister(this, 'compact_toolbar');
+            CleanupRegistry.register(this, onoff('click', this.#handleMenuClick, this.#compactToolbarItem).on(), 'compact_toolbar');
+        }
+        this.#compactToolbarItem.innerHTML = `<label-view slot="label" system-image="dots-three"></label-view>`;
+        for (const node of this.#slots?.get('column')?.assignedElements({ flatten: true }) ?? []) {
+            if (!node.matches('[is=table-column]'))
+                continue;
+            const btn = $(`<button type="button" tabindex="0">
+        <v-stack spacing="0" alignment="leading">
+          <label-view></label-view>
+          <label-view font="callout" foreground="secondary"></label-view>
+        </v-stack>
+      </button>`, '>1'), title = btn.querySelector('label-view:first-child'), subTitle = btn.querySelector('label-view:last-child');
+            title?.setAttribute('title', node.textContent.trim());
+            subTitle?.setAttribute('title', node.ariaSort ?? '');
+            this.#compactToolbarItem.appendChild(btn);
+        }
+        // const wasConnected = this.#compactToolbarItem?.isConnected
+        // this.#compactToolbarItem?.removeEventListener('click', this.#handleMenuClick)
+        // this.#compactToolbarItem?.remove()
+        // this.#compactToolbarItem = menu
+        // this.#compactToolbarItem?.addEventListener('click', this.#handleMenuClick)
+        // if (wasConnected) this.insertAdjacentElement('beforeend', this.#compactToolbarItem)
+    };
+    #handleStyleChange = () => {
+        console.debug(`${_a.name} ⚡️ style`);
+        const target = this.#shadowRoot.querySelector('[part*=table-container]') ?? undefined;
+        if (!target)
+            return;
+        const style = self.getComputedStyle(target);
+        const adaptableTableStyle = style.getPropertyValue('--adaptable-table-style') || 'compact';
+        switch (adaptableTableStyle) {
+            case 'expanded':
+                if (!this.#compactToolbarItem?.isConnected)
+                    break;
+                this.#compactToolbarItem?.remove();
+                break;
+            default:
+                if (!this.#compactToolbarItem)
+                    break;
+                if (this.#compactToolbarItem?.isConnected)
+                    break;
+                this.insertAdjacentElement('beforeend', this.#compactToolbarItem);
+                break;
+        }
+    };
+    #handleMenuClick = (evt) => {
+        const target = evt.target instanceof HTMLElement && evt.target;
+        if (!target)
+            return;
+        const btn = target.closest('button');
+        if (!btn)
+            return;
+        const siblings = [...(btn.parentNode?.querySelectorAll(':scope>button') ?? [])];
+        const index = siblings.indexOf(btn);
+        this.querySelector(`:scope>[slot=column]:nth-of-type(${index + 1})`)?.click();
+    };
+}
+_a = TableView;

package/generated/components/text-field.d.ts

@@ -0,0 +1,29 @@
+import { FormAssociatedBase } from '../internal/class/form-associated-base';
+declare const keyboardTypes: readonly ["decimal-pad", "number-pad", "default"];
+export type KeyboardType = (typeof keyboardTypes)[number];
+/**
+ * @slot label
+ * @slot validity-options
+ */
+export declare class TextField extends FormAssociatedBase {
+    #private;
+    static get observedAttributes(): string[];
+    static get template(): DocumentFragment;
+    constructor();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string, oldValue: string | null, newValue: string | null): void;
+    get keyboardType(): KeyboardType;
+    get text(): string;
+    set text(v: string);
+    get name(): string;
+    get value(): string;
+    get valueAsNumber(): number | "";
+    get negativeNumbersAllowed(): boolean;
+    setValidity: (flags?: ValidityStateFlags, message?: string, anchor?: HTMLElement) => void;
+    setCustomValidity: (message: string) => void;
+    formAssociatedCallback: (form: HTMLFormElement) => void;
+    formDisabledCallback: (disabled: boolean) => void;
+    formResetCallback: () => void;
+}
+export {};