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

package/generated/internal/class/mutation-observer-singleton.js

@@ -0,0 +1,46 @@
+import { Snapshot } from '../../snapshot';
+export class MutationObserverSingleton {
+    #observers = new WeakMap();
+    observer;
+    constructor() {
+        this.observer = Snapshot.waitReady.then(() => {
+            return new MutationObserver((entries) => {
+                for (const entry of entries)
+                    this.#observers.get(entry.target)?.(entry);
+            });
+        });
+    }
+    async observe(target, callback, options) {
+        this.#observers.set(target, callback);
+        (await this.observer).observe(target, options);
+    }
+    async unobserve(target) {
+        ;
+        (await this.observer).disconnect();
+        this.#observers.delete(target);
+    }
+    /** Observes automatically all elements using a Set provided by outside. Calls renderCallback on EVERY change. */
+    async syncObservations(set, nodes, renderCallback, attributeFilter) {
+        for (const el of set)
+            if (!nodes.includes(el)) {
+                this.unobserve(el);
+                set.delete(el);
+            }
+        for (const el of nodes) {
+            if (!set.has(el))
+                this.observe(el, renderCallback, {
+                    attributes: true,
+                    characterData: true,
+                    subtree: true,
+                    childList: true,
+                    ...(attributeFilter && { attributeFilter }),
+                });
+            set.add(el);
+        }
+    }
+    async clearObservationsSet(set) {
+        for (const el of set)
+            this.unobserve(el);
+        set.clear();
+    }
+}

package/generated/internal/class/navigation-path.d.ts

@@ -0,0 +1,15 @@
+import type * as Components from '../../components';
+import { type NavigationHost, type NavigationPage, type NavigationToolbarConfiguration } from '../privateNamespace';
+export declare class NavigationPath {
+    #private;
+    get component(): NavigationHost | undefined;
+    get body(): Components.ScrollView | null | undefined;
+    get page(): NavigationPage | null | undefined;
+    get toolBarConfig(): NavigationToolbarConfiguration[] | undefined;
+    get slot(): NavigationHost | null | undefined;
+    constructor(any?: HTMLElement);
+    hydrate(): this;
+    children(): Generator<NavigationPath>;
+    parents(): Generator<NavigationPath>;
+    [Symbol.iterator](): Generator<NavigationPath>;
+}

package/generated/internal/class/navigation-path.js

@@ -0,0 +1,84 @@
+/**
+ * Gets current host (closest)
+ */
+function closestHost(any) {
+    return any?.closest('body-view,[is=sheet-view],navigation-stack,navigation-split-view') ?? undefined;
+}
+export class NavigationPath {
+    #component;
+    #slot;
+    #body;
+    #page;
+    #toolBarConfig;
+    get component() {
+        return this.#component;
+    }
+    get body() {
+        if (undefined === this.#body)
+            this.#queryBody();
+        return this.#body;
+    }
+    get page() {
+        if (undefined === this.#page)
+            this.#queryPage();
+        return this.#page;
+    }
+    get toolBarConfig() {
+        if (undefined === this.#toolBarConfig)
+            this.#queryToolBarConfig();
+        return this.#toolBarConfig;
+    }
+    get slot() {
+        if (undefined === this.#slot)
+            this.#querySlot();
+        return this.#slot;
+    }
+    constructor(any) {
+        this.#component = closestHost(any);
+    }
+    #queryBody() {
+        this.#body = closestHost(this.#component)?.querySelector(`:scope>scroll-view,:scope>[is=sidebar-view]>scroll-view`) ?? null;
+    }
+    #queryPage() {
+        this.#page = this.#component?.querySelector(':scope>scroll-view,:scope>[is=sidebar-view]') ?? null;
+    }
+    #queryToolBarConfig() {
+        this.#toolBarConfig = [
+            ...(this.#component?.querySelectorAll(`:scope>tool-bar>tool-bar-item,:scope>tool-bar>tool-bar-item-group,:scope>[is=sidebar-view]>tool-bar>tool-bar-item,:scope>[is=sidebar-view]>tool-bar>tool-bar-item-group`) ?? []),
+        ];
+    }
+    #querySlot() {
+        this.#slot =
+            this.#component?.querySelector(':scope>body-view:not([hidden]),:scope>[is=sheet-view]:not([hidden]),:scope>navigation-stack:not([hidden]),:scope>navigation-split-view:not([hidden])') ?? null;
+    }
+    hydrate() {
+        this.#queryBody();
+        this.#queryPage();
+        this.#queryToolBarConfig();
+        this.#querySlot();
+        return this;
+    }
+    *children() {
+        if (!this.slot)
+            return;
+        const child = new NavigationPath(this.slot);
+        yield child;
+        yield* child.children();
+    }
+    *parents() {
+        if (!this.#component)
+            return;
+        let el = this.#component.parentElement;
+        while (el) {
+            const host = closestHost(el);
+            if (!host)
+                break;
+            yield new NavigationPath(host);
+            el = host.parentElement;
+        }
+    }
+    *[Symbol.iterator]() {
+        yield this;
+        yield* this.children();
+    }
+}

package/generated/internal/class/navigation-view.d.ts

@@ -0,0 +1,8 @@
+export declare class NavigationView extends HTMLElement {
+    #private;
+    static get observedAttributes(): string[];
+    constructor();
+    disconnectedCallback(): void;
+    connectedCallback(): void;
+    attributeChangedCallback(name: string, oldValue: string | null, newValue: string | null): void;
+}

package/generated/internal/class/navigation-view.js

@@ -0,0 +1,77 @@
+var _a;
+import { lifecycleObserver } from '../../buses';
+import { CleanupRegistry } from '../../internal/class/cleanup-registry';
+import { frame, onoff } from '../utils';
+export class NavigationView extends HTMLElement {
+    static get observedAttributes() {
+        return ['hidden'];
+    }
+    // pairedEventSystem
+    #recentBefore;
+    constructor() {
+        super();
+    }
+    disconnectedCallback() {
+        CleanupRegistry.unregister(this);
+        this.#recentBefore = undefined;
+        // this.removeEventListener('tabreveal', this.#handleTabReveal)
+        if (this.closest('tab-view'))
+            frame().then(() => lifecycleObserver.dispatchEvent(new CustomEvent('tabhide', { detail: { tag: this.id }, bubbles: true, composed: true })));
+    }
+    connectedCallback() {
+        if (this.closest('tab-view')) {
+            // frame(this).then((r) => {
+            //   if (!r) return
+            //   this.dispatchEvent(new CustomEvent<TabDetail>('tabshow', { detail: { tag: this.id }, bubbles: true, composed: true }))
+            // })
+            CleanupRegistry.register(this, onoff('beforetabreveal beforetabswap', this.#handleBeforeTabRevealOrSwap, this).on());
+        }
+        // Snapshot.waitReady.then(async () => {
+        if (this.hasAttribute('hidden'))
+            return; // will be picked up by attr-change!
+        if (this.closest('tab-view'))
+            frame(this).then(() => {
+                // if (!r) return
+                lifecycleObserver.dispatchEvent(new CustomEvent('tabshow', { detail: { tag: this.id }, bubbles: true, composed: true }));
+            });
+    }
+    attributeChangedCallback(name, oldValue, newValue) {
+        switch (name) {
+            case 'hidden':
+                if (oldValue === newValue)
+                    break;
+                if (!this.closest('tab-view'))
+                    break; // tabview stuff
+                let eventType = this.hasAttribute(name) ? 'tabhide' : 'tabshow', target = lifecycleObserver;
+                // isRecent by 100ms window
+                if (this.#recentBefore && performance.now() - this.#recentBefore.time <= 100) {
+                    if (this.#recentBefore.type === 'beforetabreveal') {
+                        eventType = 'tabreveal';
+                        target = this;
+                    }
+                    else if (this.#recentBefore.type === 'beforetabswap') {
+                        eventType = 'tabswap';
+                        target = this;
+                    }
+                    // consume it (important so it doesn’t leak to next change)
+                    this.#recentBefore = undefined;
+                }
+                console.debug(`${_a.name} 💡 ${eventType}`);
+                frame(this).then(() => {
+                    // if (!r) return
+                    target.dispatchEvent(new CustomEvent(eventType, { detail: { tag: this.id }, bubbles: true, composed: true }));
+                });
+                break;
+        }
+    }
+    #handleBeforeTabRevealOrSwap = (evt) => {
+        console.debug(`${_a.name} ⚡️ ${evt?.type}`);
+        if (this.id !== evt.detail?.tag)
+            return;
+        this.#recentBefore = {
+            type: evt.type, // beforetabreveal / beforetabswap
+            time: performance.now(),
+        };
+    };
+}
+_a = NavigationView;

package/generated/internal/class/resize-observer-singleton.d.ts

@@ -0,0 +1,7 @@
+export declare class ResizeObserverSingleton {
+    #private;
+    readonly observer: Promise<ResizeObserver>;
+    constructor();
+    observe(target: Element, callback: (entry: ResizeObserverEntry) => void): Promise<void>;
+    unobserve(target: Element): Promise<void>;
+}

package/generated/internal/class/resize-observer-singleton.js

@@ -0,0 +1,22 @@
+import { Snapshot } from '../../snapshot';
+export class ResizeObserverSingleton {
+    #observers = new WeakMap();
+    observer;
+    constructor() {
+        this.observer = Snapshot.waitReady.then(() => {
+            return new ResizeObserver((entries) => {
+                for (const entry of entries)
+                    this.#observers.get(entry.target)?.(entry);
+            });
+        });
+    }
+    async observe(target, callback) {
+        this.#observers.set(target, callback);
+        (await this.observer).observe(target);
+    }
+    async unobserve(target) {
+        ;
+        (await this.observer).unobserve(target);
+        this.#observers.delete(target);
+    }
+}

package/generated/internal/decorators/custom-element.d.ts

@@ -0,0 +1,5 @@
+export declare function customElement<T extends {
+    new (...args: any[]): {};
+}>(constructor: T): {
+    new (...args: any[]): {};
+} & T;

package/generated/internal/decorators/custom-element.js

@@ -0,0 +1,4 @@
+export function customElement(constructor) {
+    return class extends constructor {
+    };
+}

package/generated/internal/privateNamespace.d.ts

@@ -0,0 +1,4 @@
+import type * as Components from '../components';
+export type NavigationHost = Components.BodyView | Components.SheetView | Components.NavigationStack | Components.NavigationSplitView;
+export type NavigationToolbarConfiguration = Components.ToolBarItem | Components.ToolBarItemGroup;
+export type NavigationPage = Components.SidebarView | Components.ScrollView;

package/generated/internal/privateNamespace.js

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

package/generated/internal/utils/add.d.ts

@@ -0,0 +1 @@
+export default function <T extends object>(set: Set<T> | WeakSet<T>, value: T): boolean;

package/generated/internal/utils/add.js

@@ -0,0 +1,7 @@
+export default function (set, value) {
+    if (!set.has(value)) {
+        set.add(value);
+        return true;
+    }
+    return false;
+}

package/generated/internal/utils/button-role.d.ts

@@ -0,0 +1 @@
+export default function (target: HTMLElement, role: string | null, titleKey?: string | null): void;

package/generated/internal/utils/button-role.js

@@ -0,0 +1,59 @@
+import { I18n } from '../../i18n';
+import { Snapshot } from '../../snapshot';
+import { CleanupRegistry } from '../class/cleanup-registry';
+import { default as $ } from './cash';
+import onoff from './onoff';
+function renderPlaceholder(el, role, titleKey) {
+    if (!el.isConnected)
+        return;
+    self.requestAnimationFrame(() => {
+        if (!el.isConnected)
+            return;
+        const label = el.querySelector(':scope>[slot=placeholder]') ?? el.appendChild($(`<label-view slot="placeholder"></label-view>`, '>1'));
+        switch (role) {
+            case 'cancel':
+                label.setAttribute('title', titleKey && titleKey in I18n.t('ButtonRole') ? I18n.t('ButtonRole')[titleKey] : I18n.t('ButtonRole').Cancel);
+                label.setAttribute('system-image', Snapshot.config['cancel-button-icon']);
+                break;
+            case 'close':
+                if (label.closest('[is=alert-dialog]')) {
+                    label.setAttribute('title', titleKey && titleKey in I18n.t('ButtonRole') ? I18n.t('ButtonRole')[titleKey] : I18n.t('ButtonRole').OK);
+                }
+                else {
+                    label.setAttribute('title', titleKey && titleKey in I18n.t('ButtonRole') ? I18n.t('ButtonRole')[titleKey] : I18n.t('ButtonRole').Close);
+                    label.setAttribute('system-image', Snapshot.config['close-button-icon']);
+                }
+                break;
+            case 'confirm':
+                label.setAttribute('title', titleKey && titleKey in I18n.t('ButtonRole') ? I18n.t('ButtonRole')[titleKey] : I18n.t('ButtonRole').Confirm);
+                label.setAttribute('system-image', Snapshot.config['confirm-button-icon']);
+                break;
+            case 'confirmation-action':
+                label.setAttribute('title', titleKey && titleKey in I18n.t('ButtonRole') ? I18n.t('ButtonRole')[titleKey] : I18n.t('ButtonRole').Confirm);
+                label.setAttribute('system-image', Snapshot.config['confirm-button-icon']);
+                break;
+            case 'cancellation-action':
+                label.setAttribute('title', titleKey && titleKey in I18n.t('ButtonRole') ? I18n.t('ButtonRole')[titleKey] : I18n.t('ButtonRole').Cancel);
+                label.setAttribute('system-image', Snapshot.config['cancel-button-icon']);
+                break;
+            case 'destructive':
+                label.setAttribute('title', titleKey && titleKey in I18n.t('ButtonRole') ? I18n.t('ButtonRole')[titleKey] : I18n.t('ButtonRole').Destructive);
+                label.setAttribute('system-image', Snapshot.config['delete-button-icon']);
+                break;
+            default:
+                label?.remove();
+                break;
+        }
+        // if (role) {
+        //   label.setAttribute('title', I18n.t('ButtonRole').Default.Destructive)
+        // } else label?.remove()
+    });
+}
+export default function (target, role, titleKey) {
+    const overiderTitle = typeof titleKey === 'string' && titleKey in I18n.t('ButtonRole') ? titleKey : undefined;
+    renderPlaceholder(target, role, overiderTitle);
+    CleanupRegistry.unregister(target, 'i18n');
+    CleanupRegistry.register(target, onoff('localechange', () => {
+        renderPlaceholder(target, role, overiderTitle);
+    }, I18n.on).on(), 'i18n');
+}

package/generated/internal/utils/cash/ancestors.d.ts

@@ -0,0 +1 @@
+export default function <T extends Element>(selector: string, element?: Element): T[];

package/generated/internal/utils/cash/ancestors.js

@@ -0,0 +1,27 @@
+export default function (selector, element) {
+    const matches = [];
+    let current = element?.closest(selector) ?? undefined;
+    while (current) {
+        matches.push(current);
+        current = current.parentElement?.closest(selector) ?? undefined;
+    }
+    return matches;
+}
+// function querySelectorAllUp(el, selector) {
+//   const matches = [];
+//   let current = el.parentElement;
+//   while (current) {
+//     if (current.matches(selector)) matches.push(current);
+//     current = current.parentElement;
+//   }
+//   return matches;
+// }
+// function querySelectorAllUp(el, selector) {
+//   const matches = [];
+//   let current = el.closest(selector);
+//   while (current) {
+//     matches.push(current);
+//     current = current.parentElement?.closest(selector);
+//   }
+//   return matches;
+// }

package/generated/internal/utils/cash/index.d.ts

@@ -0,0 +1,23 @@
+import ancestors from './ancestors';
+import next from './next';
+import nextAll from './next-all';
+import prev from './prev';
+import prevAll from './prev-all';
+import prop from './prop';
+import siblings from './siblings';
+declare const DEFAULT: ">1";
+interface CashFn {
+    (innerHTML: string): DocumentFragment;
+    <T extends Element = Element>(innerHTML: string, selector: typeof DEFAULT): T;
+    <T extends Element = Element>(innerHTML: string, selector: string): T;
+    prop: typeof prop;
+    nextAll: typeof nextAll;
+    prevAll: typeof prevAll;
+    next: typeof next;
+    prev: typeof prev;
+    siblings: typeof siblings;
+    ancestors: typeof ancestors;
+}
+declare const cash: CashFn;
+export default cash;
+export { ancestors, next, nextAll, prev, prevAll, prop, siblings };

package/generated/internal/utils/cash/index.js

@@ -0,0 +1,25 @@
+import ancestors from './ancestors';
+import next from './next';
+import nextAll from './next-all';
+import prev from './prev';
+import prevAll from './prev-all';
+import prop from './prop';
+import siblings from './siblings';
+const DEFAULT = '>1';
+const cash = ((innerHTML, selector) => {
+    const template = Object.assign(document.createElement('template'), { innerHTML });
+    if (!selector)
+        return template.content;
+    if (selector === DEFAULT)
+        return template.content.firstElementChild; // OVERKILL
+    return template.content.querySelector('>1' === selector ? ':first-child' : selector);
+});
+cash.prop = prop;
+cash.nextAll = nextAll;
+cash.prevAll = prevAll;
+cash.next = next;
+cash.prev = prev;
+cash.siblings = siblings;
+cash.ancestors = ancestors;
+export default cash;
+export { ancestors, next, nextAll, prev, prevAll, prop, siblings };

package/generated/internal/utils/cash/next-all.d.ts

@@ -0,0 +1 @@
+export default function <T extends Element>(selector?: string, element?: Element): T[];

package/generated/internal/utils/cash/next-all.js

@@ -0,0 +1,10 @@
+export default function (selector, element) {
+    const siblings = [];
+    let next = element?.nextElementSibling;
+    while (next) {
+        if (!selector || next.matches(selector))
+            siblings.push(next);
+        next = next.nextElementSibling;
+    }
+    return siblings;
+}

package/generated/internal/utils/cash/next.d.ts

@@ -0,0 +1 @@
+export default function <T extends Element>(selector?: string, element?: Element): T | undefined;

package/generated/internal/utils/cash/next.js

@@ -0,0 +1,9 @@
+export default function (selector, element) {
+    let next = element?.nextElementSibling;
+    while (next) {
+        if (!selector || next.matches(selector))
+            return next;
+        next = next.nextElementSibling;
+    }
+    return undefined;
+}

package/generated/internal/utils/cash/prev-all.d.ts

@@ -0,0 +1 @@
+export default function <T extends Element>(selector?: string, element?: Element): T[];

package/generated/internal/utils/cash/prev-all.js

@@ -0,0 +1,10 @@
+export default function (selector, element) {
+    const siblings = [];
+    let prev = element?.previousElementSibling;
+    while (prev) {
+        if (!selector || prev.matches(selector))
+            siblings.push(prev);
+        prev = prev.previousElementSibling;
+    }
+    return siblings;
+}

package/generated/internal/utils/cash/prev.d.ts

@@ -0,0 +1 @@
+export default function <T extends Element>(selector?: string, element?: Element): T | undefined;

package/generated/internal/utils/cash/prev.js

@@ -0,0 +1,9 @@
+export default function (selector, element) {
+    let prev = element?.previousElementSibling;
+    while (prev) {
+        if (!selector || prev.matches(selector))
+            return prev;
+        prev = prev.previousElementSibling;
+    }
+    return undefined;
+}

package/generated/internal/utils/cash/prop.d.ts

@@ -0,0 +1,18 @@
+/**
+ * A remove/set property utility that checks before doing DOM manipulations.
+ * It enforces the important flag, the built-in functionality is to leave it as-is if there was an important flat and the setProperty does not have one
+ * In case of undefined it does a removeProperty, the built-in functionality is to add a string representation ("undefined")
+ *
+ * Notes:
+ * By default setProperty does NOT enforce important. It always triggers a DOM manipulation.
+ * By default getPropertyValue returns a trimmed string but fails to inform of the presence in the style attribute.
+ *
+ * Examples:
+ * [style]                            prop('--prop', '1rem', el) style="--prop: 1rem;"
+ * [style]                            prop('--prop', null | '' | undefined, el) style
+ * [style]                            prop('--prop', ' ', el) style="--prop: ;"
+ * [style]                            prop('--prop', '  ', el) style="--prop:  ;"
+ * style="--prop: 1rem;"              prop('--prop', '1rem', el, 'important') style="--prop: 1rem !important;"
+ * style="--prop: 1rem !important;"   prop('--prop', '1rem', el) style="--prop: 1rem;"
+ */
+export default function (property: string, value?: string | null, el?: HTMLElement | null, priority?: 'important'): void;

package/generated/internal/utils/cash/prop.js

@@ -0,0 +1,30 @@
+/**
+ * A remove/set property utility that checks before doing DOM manipulations.
+ * It enforces the important flag, the built-in functionality is to leave it as-is if there was an important flat and the setProperty does not have one
+ * In case of undefined it does a removeProperty, the built-in functionality is to add a string representation ("undefined")
+ *
+ * Notes:
+ * By default setProperty does NOT enforce important. It always triggers a DOM manipulation.
+ * By default getPropertyValue returns a trimmed string but fails to inform of the presence in the style attribute.
+ *
+ * Examples:
+ * [style]                            prop('--prop', '1rem', el) style="--prop: 1rem;"
+ * [style]                            prop('--prop', null | '' | undefined, el) style
+ * [style]                            prop('--prop', ' ', el) style="--prop: ;"
+ * [style]                            prop('--prop', '  ', el) style="--prop:  ;"
+ * style="--prop: 1rem;"              prop('--prop', '1rem', el, 'important') style="--prop: 1rem !important;"
+ * style="--prop: 1rem !important;"   prop('--prop', '1rem', el) style="--prop: 1rem;"
+ */
+export default function (property, value, el, priority) {
+    if (!el)
+        return;
+    if (!value) {
+        if (-1 !== Array.from(el.style).indexOf(property))
+            el.style.removeProperty(property); // remove key entirely
+        return;
+    }
+    const currentValue = el.style.getPropertyValue(property), // "" always trimmed
+    currentPriority = el.style.getPropertyPriority(property); // "" always lowercase
+    if (currentValue !== value.trim() || currentPriority !== (priority ?? '').toLowerCase())
+        el.style.setProperty(property, value, priority); // enforce priority
+}

package/generated/internal/utils/cash/siblings.d.ts

@@ -0,0 +1 @@
+export default function <T extends Element>(selector?: string, element?: Element): T[];

package/generated/internal/utils/cash/siblings.js

@@ -0,0 +1,10 @@
+export default function (selector, element) {
+    const siblings = [];
+    let child = element?.parentElement?.firstElementChild;
+    while (child) {
+        if (child !== element && (!selector || child.matches(selector)))
+            siblings.push(child);
+        child = child.nextElementSibling;
+    }
+    return siblings;
+}

package/generated/internal/utils/clamp.d.ts

@@ -0,0 +1 @@
+export default function (value?: string, min?: number, max?: number): number;

package/generated/internal/utils/clamp.js

@@ -0,0 +1,4 @@
+export default function (value, min = Infinity, max = Infinity) {
+    const intVal = Math.floor(Number(value));
+    return Math.min(Math.max(intVal, min), max);
+}

package/generated/internal/utils/compare-big-decimals.d.ts

@@ -0,0 +1 @@
+export default function (a: string, b: string): number;