@swiftwc/ui 0.0.0-dev.6 → 0.0.0-dev.8

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

@@ -0,0 +1,77 @@
+var _a;
+import { CleanupRegistry } from '../../internal/class/cleanup-registry';
+import { LifecycleObserver } from '../../lifecycle-observer';
+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) ? 'tabshow' : 'tabhide', 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/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,22 @@
+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: ":scope>:first-child";
+interface CashFn {
+    (innerHTML: string, selector?: typeof DEFAULT): Element;
+    (innerHTML: string, selector: string): DocumentFragment;
+    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,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';
+const DEFAULT = ':scope>:first-child';
+const cash = ((innerHTML, selector = DEFAULT) => {
+    const template = Object.assign(document.createElement('template'), { innerHTML });
+    if (selector === DEFAULT)
+        return template.content.firstElementChild;
+    return template.content;
+});
+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;

package/generated/internal/utils/compare-big-decimals.js

@@ -0,0 +1,90 @@
+/**
+ * @example
+ * compareBigDecimals("1e3", "1000") // 0
+ * compareBigDecimals("1e-3", "0.001") // 0
+ * compareBigDecimals("-10", "-2") // -1 ✅
+ * const arr = ["1.2","1.10","1.02","1e2","100","-0.5"]
+ * arr.sort(compareBigDecimals)
+ * console.log(arr)
+ * function isInRange(value: string, min: string, max: string): boolean {return compareBigDecimals(value, min) >= 0 && compareBigDecimals(value, max) <= 0}
+ * // examples
+ * isInRange("-5", "-10", "-1")   // true
+ * isInRange("-11", "-10", "-1")  // false
+ * isInRange("0", "-10", "-1")    // false
+ * isInRange("-Infinity", "-Infinity", "-1")  // true
+ * isInRange("5", "-Infinity", "Infinity")    // true
+ */
+const POSITIVE_INFINITY = 'Infinity', NEGATIVE_INFINITY = '-Infinity';
+export default function (a, b) {
+    const aInf = isInfinity(a), bInf = isInfinity(b);
+    if (aInf !== 0 || bInf !== 0) {
+        if (aInf === bInf)
+            return 0;
+        return aInf > bInf ? 1 : -1;
+    }
+    const A = parse(a), B = parse(b);
+    // different signs
+    if (A.sign !== B.sign)
+        return A.sign - B.sign;
+    const sign = A.sign;
+    // compare integer length
+    if (A.i.length !== B.i.length)
+        return (A.i.length - B.i.length) * sign;
+    // compare integer part
+    if (A.i !== B.i)
+        return (A.i > B.i ? 1 : -1) * sign;
+    // compare fractional part
+    const max = Math.max(A.f.length, B.f.length);
+    for (let i = 0; i < max; i++) {
+        const da = A.f.charCodeAt(i) || 48, // '0'
+        db = B.f.charCodeAt(i) || 48;
+        if (da !== db)
+            return (da > db ? 1 : -1) * sign;
+    }
+    return 0;
+}
+function isInfinity(s) {
+    const t = s.trim();
+    if (t === POSITIVE_INFINITY || t === '+Infinity')
+        return 1;
+    if (t === NEGATIVE_INFINITY)
+        return -1;
+    return 0;
+}
+function parse(input) {
+    let s = input.trim(), sign = 1;
+    // sign
+    if (s[0] === '-') {
+        sign = -1;
+        s = s.slice(1);
+    }
+    else if (s[0] === '+') {
+        s = s.slice(1);
+    }
+    // scientific notation
+    let exp = 0;
+    const eIndex = s.search(/e/i);
+    if (eIndex !== -1) {
+        exp = parseInt(s.slice(eIndex + 1), 10) || 0;
+        s = s.slice(0, eIndex);
+    }
+    let [i = '0', f = ''] = s.split('.');
+    // remove leading zeros
+    i = i.replace(/^0+/, '') || '0';
+    // apply exponent by shifting decimal
+    if (exp > 0) {
+        const move = Math.min(exp, f.length);
+        i += f.slice(0, move);
+        f = f.slice(move) + '0'.repeat(exp - move);
+    }
+    else if (exp < 0) {
+        const move = Math.min(-exp, i.length);
+        f = i.slice(i.length - move) + f;
+        i = i.slice(0, i.length - move) || '0';
+        f = '0'.repeat(-exp - move) + f;
+    }
+    // normalize again
+    i = i.replace(/^0+/, '') || '0';
+    f = f.replace(/0+$/, '');
+    return { sign, i, f };
+}

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

@@ -0,0 +1 @@
+export default function <F extends (...args: any[]) => any>(fn: F, delay?: number, immediate?: boolean): (...args: Parameters<F>) => void;

package/generated/internal/utils/debounce.js

@@ -0,0 +1,13 @@
+import timeout from './timeout';
+export default function (fn, delay = 300, immediate = false) {
+    const { next, pending } = timeout();
+    return function (...args) {
+        const context = this, callNow = immediate && !pending();
+        next(() => {
+            if (!immediate)
+                fn.apply(context, args);
+        }, delay);
+        if (callNow)
+            fn.apply(context, args);
+    };
+}

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

@@ -0,0 +1 @@
+export default function (element?: Element): Promise<number | undefined>;

package/generated/internal/utils/frame.js

@@ -0,0 +1,6 @@
+export default function (element) {
+    return new Promise((r) => self.requestAnimationFrame(r)).then((t) => {
+        if (!element || element.isConnected)
+            return t;
+    });
+}

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

@@ -1,2 +1,17 @@
-export { default as kebabCase } from './kebab-case';
+import cash from './cash';
+export { default as add } from './add';
+export { default as clamp } from './clamp';
+export { default as compareBigDecimals } from './compare-big-decimals';
 export { default as cssTime } from './css-time';
+export { default as debounce } from './debounce';
+export { default as frame } from './frame';
+export { default as kebabCase } from './kebab-case';
+export { default as listActive } from './list-active';
+export { default as microtask } from './microtask';
+export { default as onoff } from './onoff';
+export { default as set } from './set';
+export { default as sleep } from './sleep';
+export { default as slowHideShow } from './slow-hide-show';
+export { default as timeout } from './timeout';
+export { default as touchGlass } from './touch-glass';
+export declare const $: typeof cash;

package/generated/internal/utils/index.js

@@ -1,2 +1,18 @@
-export { default as kebabCase } from './kebab-case';
+// import * as _intl from './intl'
+import cash from './cash';
+export { default as add } from './add';
+export { default as clamp } from './clamp';
+export { default as compareBigDecimals } from './compare-big-decimals';
 export { default as cssTime } from './css-time';
+export { default as debounce } from './debounce';
+export { default as frame } from './frame';
+export { default as kebabCase } from './kebab-case';
+export { default as listActive } from './list-active';
+export { default as microtask } from './microtask';
+export { default as onoff } from './onoff';
+export { default as set } from './set';
+export { default as sleep } from './sleep';
+export { default as slowHideShow } from './slow-hide-show';
+export { default as timeout } from './timeout';
+export { default as touchGlass } from './touch-glass';
+export const $ = cash;

package/generated/internal/utils/kebab-case.d.ts

@@ -1 +1 @@
-export default function (str: String): string;
+export default function (str: string): string;

package/generated/internal/utils/list-active.d.ts

@@ -0,0 +1,7 @@
+export default function (t: HTMLElement): {
+    types: string;
+    listener: EventListener;
+    addOptions: {
+        passive: boolean;
+    };
+}[];

package/generated/internal/utils/list-active.js

@@ -0,0 +1,28 @@
+function onClick(event) {
+    const el = event.target.closest('button,summary');
+    if (!el)
+        return;
+    el.classList.add('active');
+    el.addEventListener('pointerleave', onCancel);
+}
+function onCancel(event) {
+    const el = event.target.closest('button,summary');
+    if (!el)
+        return;
+    self.requestAnimationFrame(() => {
+        el.removeEventListener('pointerleave', onCancel);
+        el.classList.remove('active');
+    });
+}
+const makePointerDownHandler = (target) => {
+    return onClick;
+}, makePointerCancelHandler = (target) => {
+    return onCancel;
+};
+export default function (t) {
+    const onListener = makePointerDownHandler(t), offListener = makePointerCancelHandler(t);
+    return [
+        { types: 'pointerdown', listener: onListener, addOptions: { passive: true } },
+        { types: 'pointerup pointercancel', listener: offListener, addOptions: { passive: true } },
+    ];
+}

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

@@ -0,0 +1 @@
+export default function (): Promise<void>;

package/generated/internal/utils/microtask.js

@@ -0,0 +1,3 @@
+export default function () {
+    return Promise.resolve();
+}

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

@@ -0,0 +1,45 @@
+/**
+ * const el = document.querySelector('button')!
+ *
+ * @example
+ * // 1. Single — no event arg
+ * onoff('click', () => console.log('clicked'), el)
+ *
+ * @example
+ * // 2. Single — with event arg
+ * onoff('click', (e) => console.log(e.target), el)
+ *
+ * @example
+ * // 3. Single — with options
+ * onoff('click', (e) => console.log(e), el, { passive: true, once: true })
+ *
+ * @example
+ * // 4. Single — capture as boolean
+ * onoff('click', (e) => console.log(e), el, true)
+ *
+ * @example
+ * // 5. Array — shared t
+ * onoff([
+ *   { types: 'click', listener: (e) => console.log('click', e) },
+ *   { types: 'mouseover mouseout', listener: (e) => console.log('hover', e) },
+ * ], el)
+ *
+ * @example
+ * // 6. Using on/off
+ * const { on, off } = onoff('scroll', (e) => console.log(e), el, { passive: true })
+ * on()   // start listening
+ * off()  // stop listening
+ */
+type Options = boolean | AddEventListenerOptions;
+interface EventConfig {
+    types: string;
+    listener: EventListener;
+    addOptions?: Options;
+}
+declare function single(types: string, listener: EventListener, t?: EventTarget, addOptions?: Options): {
+    on: () => () => void;
+    off: () => void;
+};
+export default function (configs: EventConfig[], t?: EventTarget): ReturnType<typeof single>;
+export default function (types: string, listener: EventListener, t?: EventTarget, addOptions?: Options): ReturnType<typeof single>;
+export {};

package/generated/internal/utils/onoff.js

@@ -0,0 +1,31 @@
+function single(types, listener, t, addOptions) {
+    const events = types?.split(' ');
+    const removeOptions = typeof addOptions === 'boolean' ? addOptions : addOptions !== undefined && 'capture' in addOptions ? { capture: addOptions.capture } : undefined;
+    const off = () => {
+        for (const event of events)
+            t?.removeEventListener(event, listener, removeOptions);
+    }, on = () => {
+        for (const event of events)
+            t?.addEventListener(event, listener, addOptions);
+        return off;
+    };
+    return {
+        on,
+        off,
+    };
+}
+export default function (typesOrConfigs, listenerOrT, t, addOptions) {
+    if (Array.isArray(typesOrConfigs)) {
+        const element = listenerOrT, results = typesOrConfigs.map((c) => single(c.types, c.listener, element, c.addOptions)); //, c.t ?? element, c.addOptions))
+        const off = () => results.forEach((r) => r.off()), on = () => {
+            for (const r of results)
+                r.on();
+            return off;
+        };
+        return {
+            on,
+            off,
+        };
+    }
+    return single(typesOrConfigs, listenerOrT, t, addOptions);
+}