@luzmo/lucero 0.0.3 → 0.0.6

package/components/number-field/number-field.d.ts

@@ -0,0 +1,113 @@
+import { NumberFormatter, NumberParser } from '@internationalized/number';
+import { CSSResultArray, PropertyValues, TemplateResult } from 'lit';
+import './../infield-button';
+import { LuzmoTextFieldBase } from './../text-field/text-field';
+export declare const FRAMES_PER_CHANGE = 5;
+export declare const CHANGE_DEBOUNCE_MS = 100;
+export declare const indeterminatePlaceholder = "-";
+export declare const remapMultiByteCharacters: Record<string, string>;
+/**
+ * @element luzmo-number-field
+ * @slot help-text - default or non-negative help text to associate to your form element
+ * @slot negative-help-text - negative help text to associate to your form element when `invalid`
+ */
+export declare class LuzmoNumberField extends LuzmoTextFieldBase {
+    static get styles(): CSSResultArray;
+    private buttons;
+    focused: boolean;
+    _forcedUnit: string;
+    /**
+     * An `<luzmo-number-field>` element will process its numeric value with
+     * `new Intl.NumberFormat(this.resolvedLanguage, this.formatOptions).format(this.valueAsNumber)`
+     * in order to prepare it for visual delivery in the input. In order to customize this
+     * processing supply your own `Intl.NumberFormatOptions` object here.
+     *
+     * See: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat/NumberFormat
+     */
+    formatOptions: Intl.NumberFormatOptions;
+    /**
+     * Whether the stepper UI is hidden or not.
+     */
+    hideStepper: boolean;
+    indeterminate: boolean;
+    keyboardFocused: boolean;
+    max?: number;
+    min?: number;
+    /**
+     * The distance by which to alter the value of the element when taking a "step".
+     *
+     * When `this.formatOptions.style === 'percentage'` the default step will be
+     * set to 0.01 unless otherwise supplied to the element.
+     */
+    step?: number;
+    managedInput: boolean;
+    stepModifier: number;
+    set value(rawValue: number);
+    get value(): number;
+    private get inputValue();
+    _value: number;
+    private _trackingValue;
+    private lastCommitedValue?;
+    private setValue;
+    /**
+     * Retreive the value of the element parsed to a Number.
+     */
+    get valueAsString(): string;
+    set valueAsString(value: string);
+    get formattedValue(): string;
+    private decimalsChars;
+    private valueBeforeFocus;
+    private isIntentDecimal;
+    private convertValueToNumber;
+    private get _step();
+    private nextChange;
+    private changeCount;
+    private findChange;
+    private change;
+    private safty;
+    private languageResolver;
+    private handlePointerdown;
+    private startChange;
+    private doChange;
+    private handlePointermove;
+    private handlePointerup;
+    private doNextChange;
+    private stepBy;
+    private increment;
+    private decrement;
+    private handleKeydown;
+    private queuedChangeEvent;
+    protected onScroll(event: WheelEvent): void;
+    protected onFocus(): void;
+    protected onBlur(_event: FocusEvent): void;
+    private handleFocusin;
+    private handleFocusout;
+    private wasIndeterminate;
+    private indeterminateValue?;
+    protected handleChange(): void;
+    protected handleCompositionStart(): void;
+    protected handleCompositionEnd(): void;
+    private hasRecentlyReceivedPointerDown;
+    protected handleInputElementPointerdown(): void;
+    protected handleInput(event: InputEvent): void;
+    private valueWithLimits;
+    private validateInput;
+    protected get displayValue(): string;
+    protected clearNumberFormatterCache(): void;
+    protected get numberFormatter(): NumberFormatter;
+    protected clearValueFormatterCache(): void;
+    protected get valueFormatter(): NumberFormatter;
+    private _numberFormatter?;
+    private _numberFormatterFocused?;
+    private _valueFormatter?;
+    protected get numberParser(): NumberParser;
+    applyFocusElementLabel: (value?: string) => void;
+    private _numberParser?;
+    private _numberParserFocused?;
+    protected renderField(): TemplateResult;
+    protected update(changes: PropertyValues): void;
+    willUpdate(changes: PropertyValues): void;
+    private isComposing;
+    protected firstUpdated(changes: PropertyValues): void;
+    protected updated(changes: PropertyValues<this>): void;
+}

package/components/observe-slot-text-DeSKIzvP.cjs

@@ -0,0 +1,18 @@
+/*! * Lucero - The design system for Luzmo.
+ * 
+ * Copyright © 2025 Luzmo
+ * All rights reserved.
+ * Lucero (“Luzmo Design System”) must be used according to the Luzmo Terms of Service.
+ * This license allows users with a current active Luzmo account to use Lucero.
+ * This license terminates automatically if a user no longer has an active Luzmo account.
+ * Please view the Luzmo Terms of Service at: https://www.luzmo.com/information-pages/terms-of-use.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ * */
+"use strict";const b=require("./mutation-controller-DkOMCW-c.cjs"),g=require("./base-rtxi7uaR.cjs"),x=require("./query-assigned-nodes-BcKWmGzy.cjs");var m=Object.defineProperty,h=(d,n,i,u)=>{for(var t=void 0,r=d.length-1,o;r>=0;r--)(o=d[r])&&(t=o(n,i,t)||t);return t&&m(n,i,t),t};const c=Symbol("assignedNodes");function v(d,n,i=[]){var u,t;const r=f=>e=>f.matches(e);class o extends(t=d,u=c,t){constructor(...e){super(e),this.slotHasContent=!1,new b.s(this,{config:{characterData:!0,subtree:!0},callback:l=>{for(const s of l)if(s.type==="characterData"){this.manageTextObservedSlot();return}}})}manageTextObservedSlot(){if(!this[c])return;const e=[...this[c]].filter(l=>{const s=l;return s.tagName?!i.some(r(s)):s.textContent?s.textContent.trim():!1});this.slotHasContent=e.length>0}update(e){if(!this.hasUpdated){const{childNodes:l}=this,s=[...l].filter(p=>{const a=p;return a.tagName?i.some(r(a))?!1:n?a.getAttribute("slot")===n:!a.hasAttribute("slot"):a.textContent?a.textContent.trim():!1});this.slotHasContent=s.length>0}super.update(e)}firstUpdated(e){super.firstUpdated(e),this.updateComplete.then(()=>{this.manageTextObservedSlot()})}}return h([g.n({type:Boolean,attribute:!1})],o.prototype,"slotHasContent"),h([x.n({slot:n,flatten:!0})],o.prototype,u),o}exports.ObserveSlotText=v;

package/components/observe-slot-text-DrM71me1.js

@@ -0,0 +1,87 @@
+/*! * Lucero - The design system for Luzmo.
+ * 
+ * Copyright © 2025 Luzmo
+ * All rights reserved.
+ * Lucero (“Luzmo Design System”) must be used according to the Luzmo Terms of Service.
+ * This license allows users with a current active Luzmo account to use Lucero.
+ * This license terminates automatically if a user no longer has an active Luzmo account.
+ * Please view the Luzmo Terms of Service at: https://www.luzmo.com/information-pages/terms-of-use.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ * */
+import { s as m } from "./mutation-controller-DH7YOCyj.js";
+import { n as x } from "./base-CxUap9HL.js";
+import { n as b } from "./query-assigned-nodes-C76XVPWY.js";
+var g = Object.defineProperty, p = (d, n, i, f) => {
+  for (var t = void 0, o = d.length - 1, r; o >= 0; o--)
+    (r = d[o]) && (t = r(n, i, t) || t);
+  return t && g(n, i, t), t;
+};
+const u = Symbol("assignedNodes");
+function y(d, n, i = []) {
+  var f, t;
+  const o = (c) => (e) => c.matches(e);
+  class r extends (t = d, f = u, t) {
+    constructor(...e) {
+      super(e), this.slotHasContent = !1, new m(this, {
+        config: {
+          characterData: !0,
+          subtree: !0
+        },
+        callback: (l) => {
+          for (const s of l)
+            if (s.type === "characterData") {
+              this.manageTextObservedSlot();
+              return;
+            }
+        }
+      });
+    }
+    manageTextObservedSlot() {
+      if (!this[u])
+        return;
+      const e = [...this[u]].filter(
+        (l) => {
+          const s = l;
+          return s.tagName ? !i.some(o(s)) : s.textContent ? s.textContent.trim() : !1;
+        }
+      );
+      this.slotHasContent = e.length > 0;
+    }
+    update(e) {
+      if (!this.hasUpdated) {
+        const { childNodes: l } = this, s = [...l].filter((h) => {
+          const a = h;
+          return a.tagName ? i.some(o(a)) ? !1 : (
+            // Confirm it would exist in a targeted slot if there was one supplied.
+            n ? a.getAttribute("slot") === n : !a.hasAttribute("slot")
+          ) : a.textContent ? a.textContent.trim() : !1;
+        });
+        this.slotHasContent = s.length > 0;
+      }
+      super.update(e);
+    }
+    firstUpdated(e) {
+      super.firstUpdated(e), this.updateComplete.then(() => {
+        this.manageTextObservedSlot();
+      });
+    }
+  }
+  return p([
+    x({ type: Boolean, attribute: !1 })
+  ], r.prototype, "slotHasContent"), p([
+    b({
+      slot: n,
+      flatten: !0
+    })
+  ], r.prototype, f), r;
+}
+export {
+  y as O
+};

package/components/overlay/abstract-overlay.d.ts

@@ -0,0 +1,72 @@
+import { LuzmoElement } from '../../utils/base';
+import { ElementResolutionController } from '../../utils/reactive-controllers/element-resolution';
+import type { Overlay } from './overlay';
+import { OverlayTimer } from './overlay-timer';
+import type { OpenableElement, OverlayOptions, OverlayOptionsV1, OverlayState, OverlayTypes, Placement, TriggerInteractionsV1 } from './overlay-types';
+import { PlacementController } from './placement-controller';
+import { VirtualTrigger } from './virtual-trigger';
+export declare const overlayTimer: OverlayTimer;
+export declare const noop: () => void;
+/**
+ * Apply a "transitionend" listener to an element that may not transition but
+ * guarantee the callback will be fired either way.
+ *
+ * @param el {HTMLElement} - Target of the "transition" listeners.
+ * @param action {Function} - Method to trigger the "transition".
+ * @param cb {Function} - Callback to trigger when the "transition" has ended.
+ */
+export declare const guaranteedAllTransitionend: (el: HTMLElement, action: () => void, cb: () => void) => void;
+export declare function nextFrame(): Promise<void>;
+/**
+ * Abstract Overlay base class so that property tyings and imperative API
+ * interfaces can be held separate from the actual class definition.
+ */
+export declare class AbstractOverlay extends LuzmoElement {
+    protected applyFocus(_targetOpenState: boolean, _focusEl: HTMLElement | null): void;
+    get delayed(): boolean;
+    set delayed(_delayed: boolean);
+    dialogEl: HTMLDialogElement & {
+        showPopover(): void;
+        hidePopover(): void;
+    };
+    get disabled(): boolean;
+    set disabled(_disabled: boolean);
+    dispose: () => void;
+    protected get elementResolver(): ElementResolutionController;
+    protected set elementResolver(controller: ElementResolutionController);
+    protected _elementResolver: ElementResolutionController;
+    protected ensureOnDOM(_targetOpenState: boolean): void;
+    elements: OpenableElement[];
+    protected makeTransition(_targetOpenState: boolean): HTMLElement | null;
+    protected manageDelay(_targetOpenState: boolean): void;
+    protected manageDialogOpen(): void;
+    protected managePopoverOpen(): void;
+    protected managePosition(): void;
+    protected offset: number | [number, number];
+    get open(): boolean;
+    set open(_open: boolean);
+    placement?: Placement;
+    protected get placementController(): PlacementController;
+    protected set placementController(controller: PlacementController);
+    protected _placementController: PlacementController;
+    receivesFocus: 'true' | 'false' | 'auto';
+    protected requestSlottable(): void;
+    protected returnFocus(): void;
+    get state(): OverlayState;
+    set state(_state: OverlayState);
+    protected _state: OverlayState;
+    triggerElement: HTMLElement | VirtualTrigger | null;
+    type: OverlayTypes;
+    willPreventClose: boolean;
+    manuallyKeepOpen(): void;
+    static update(): void;
+    /**
+     * Overloaded imperative API entry point that allows for both the pre-0.37.0
+     * argument signature as well as the post-0.37.0 signature. This allows for
+     * consumers to continue to leverage it as they had been in previous releases
+     * while also surfacing the more feature-rich API that has been made available.
+     */
+    static open(trigger: HTMLElement, interaction: TriggerInteractionsV1, content: HTMLElement, optionsV1: OverlayOptionsV1): Promise<() => void>;
+    static open(content: HTMLElement, options?: OverlayOptions): Promise<Overlay>;
+    static applyOptions(overlay: AbstractOverlay, options: OverlayOptions): void;
+}

package/components/overlay/click-controller.d.ts

@@ -0,0 +1,14 @@
+import { InteractionController, InteractionTypes } from './interaction-controller';
+export declare class ClickController extends InteractionController {
+    type: InteractionTypes;
+    /**
+     * An overlay with a `click` interaction should not close on click `triggerElement`.
+     * When a click is initiated (`pointerdown`), apply `preventNextToggle` when the
+     * overlay is `open` to prevent from toggling the overlay when the click event
+     * propagates later in the interaction.
+     */
+    private preventNextToggle;
+    handleClick(): void;
+    handlePointerdown(): void;
+    init(): void;
+}

package/components/overlay/events.d.ts

@@ -0,0 +1,23 @@
+import type { TriggerInteractions } from './overlay-types';
+export declare class BeforetoggleClosedEvent extends Event {
+    currentState: string;
+    newState: string;
+    constructor();
+}
+export declare class BeforetoggleOpenEvent extends Event {
+    currentState: string;
+    newState: string;
+    constructor();
+}
+export declare class OverlayStateEvent extends Event {
+    overlay: HTMLElement;
+    detail: {
+        interaction: string;
+        reason?: 'external-click';
+    };
+    constructor(type: string, overlay: HTMLElement, { publish, interaction, reason }: {
+        publish?: boolean;
+        interaction: TriggerInteractions;
+        reason?: 'external-click';
+    });
+}

package/components/overlay/full-size-plugin.d.ts

@@ -0,0 +1,12 @@
+import { MiddlewareReturn, MiddlewareState } from '@floating-ui/dom';
+export declare const fullSize: (options?: {
+    padding: number;
+}) => {
+    name: string;
+    fn(middlewareArguments: MiddlewareState): Promise<MiddlewareReturn & {
+        data: {
+            availableWidth: number;
+            availableHeight: number;
+        };
+    }>;
+};

package/components/overlay/hover-controller.d.ts

@@ -0,0 +1,20 @@
+import { InteractionController, InteractionTypes } from './interaction-controller';
+export declare class HoverController extends InteractionController {
+    type: InteractionTypes;
+    private elementIds;
+    focusedin: boolean;
+    private hoverTimeout?;
+    pointerentered: boolean;
+    handleTargetFocusin(): void;
+    handleTargetFocusout(): void;
+    handleTargetPointerenter(): void;
+    handleTargetPointerleave(): void;
+    handleHostPointerenter(): void;
+    handleHostPointerleave(): void;
+    prepareDescription(): void;
+    private prepareOverlayRelativeDescription;
+    private prepareContentRelativeDescription;
+    protected doPointerleave(): void;
+    init(): void;
+    initOverlay(): void;
+}

package/components/overlay/index.cjs

@@ -0,0 +1,73 @@
+/*! * Lucero - The design system for Luzmo.
+ * 
+ * Copyright © 2025 Luzmo
+ * All rights reserved.
+ * Lucero (“Luzmo Design System”) must be used according to the Luzmo Terms of Service.
+ * This license allows users with a current active Luzmo account to use Lucero.
+ * This license terminates automatically if a user no longer has an active Luzmo account.
+ * Please view the Luzmo Terms of Service at: https://www.luzmo.com/information-pages/terms-of-use.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ * */
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const n=require("../overlay-dn6Xe_vz.cjs"),s=require("../base-rtxi7uaR.cjs"),p=require("../state-WWHLNMRG.cjs"),u=require("../query-BL-TJj7K.cjs"),f=require("../directive-C7oCP5Bh.cjs"),O=require("../async-directive-_65ULPLK.cjs"),d=require("../slottable-request-event-BfUUt1Mh.cjs"),S=":host([disabled]) ::slotted([slot=trigger]){pointer-events:none}slot[name=longpress-describedby-descriptor]{display:none}";var $=Object.defineProperty,l=(c,e,t,r)=>{for(var i=void 0,a=c.length-1,h;a>=0;a--)(h=c[a])&&(i=h(e,t,i)||i);return i&&$(e,t,i),i};class o extends s.LuzmoElement{constructor(){super(...arguments),this.content="click hover longpress",this.offset=6,this.disabled=!1,this.receivesFocus="auto",this.clickContent=[],this.longpressContent=[],this.hoverContent=[],this.targetContent=[]}static get styles(){return[s.r(S)]}getAssignedElementsFromSlot(e){return e.assignedElements({flatten:!0})}handleTriggerContent(e){this.targetContent=this.getAssignedElementsFromSlot(e.target)}handleSlotContent(e){switch(e.target.name){case"click-content":{this.clickContent=this.getAssignedElementsFromSlot(e.target);break}case"longpress-content":{this.longpressContent=this.getAssignedElementsFromSlot(e.target);break}case"hover-content":{this.hoverContent=this.getAssignedElementsFromSlot(e.target);break}}}handleBeforetoggle(e){const{target:t}=e;let r;if(t===this.clickOverlayElement)r="click";else if(t===this.longpressOverlayElement)r="longpress";else if(t===this.hoverOverlayElement)r="hover";else return;e.newState==="open"?this.open=r:this.open===r&&(this.open=void 0)}update(e){var t,r,i,a,h,g;e.has("clickContent")&&(this.clickPlacement=((t=this.clickContent[0])==null?void 0:t.getAttribute("placement"))||((r=this.clickContent[0])==null?void 0:r.getAttribute("direction"))||void 0),e.has("hoverContent")&&(this.hoverPlacement=((i=this.hoverContent[0])==null?void 0:i.getAttribute("placement"))||((a=this.hoverContent[0])==null?void 0:a.getAttribute("direction"))||void 0),e.has("longpressContent")&&(this.longpressPlacement=((h=this.longpressContent[0])==null?void 0:h.getAttribute("placement"))||((g=this.longpressContent[0])==null?void 0:g.getAttribute("direction"))||void 0),super.update(e)}renderSlot(e){return s.x`
+      <slot name=${e} @slotchange=${this.handleSlotContent}></slot>
+    `}renderClickOverlay(){Promise.resolve().then(()=>require("../overlay-dn6Xe_vz.cjs")).then(t=>t.overlay);const e=this.renderSlot("click-content");return this.clickContent.length===0?e:s.x`
+      <luzmo-overlay
+        id="click-overlay"
+        ?disabled=${this.disabled||this.clickContent.length===0}
+        ?open=${this.open==="click"&&this.clickContent.length>0}
+        .offset=${this.offset}
+        .placement=${this.clickPlacement||this.placement}
+        .triggerElement=${this.targetContent[0]}
+        .triggerInteraction=${"click"}
+        .type=${this.type==="modal"?"modal":"auto"}
+        @beforetoggle=${this.handleBeforetoggle}
+        .receivesFocus=${this.receivesFocus}
+      >
+        ${e}
+      </luzmo-overlay>
+    `}renderHoverOverlay(){Promise.resolve().then(()=>require("../overlay-dn6Xe_vz.cjs")).then(t=>t.overlay);const e=this.renderSlot("hover-content");return this.hoverContent.length===0?e:s.x`
+      <luzmo-overlay
+        id="hover-overlay"
+        ?open=${this.open==="hover"&&this.hoverContent.length>0}
+        ?disabled=${this.disabled||this.hoverContent.length===0||!!this.open&&this.open!=="hover"}
+        .offset=${this.offset}
+        .placement=${this.hoverPlacement||this.placement}
+        .triggerElement=${this.targetContent[0]}
+        .triggerInteraction=${"hover"}
+        .type=${"hint"}
+        @beforetoggle=${this.handleBeforetoggle}
+        .receivesFocus=${this.receivesFocus}
+      >
+        ${e}
+      </luzmo-overlay>
+    `}renderLongpressOverlay(){Promise.resolve().then(()=>require("../overlay-dn6Xe_vz.cjs")).then(t=>t.overlay);const e=this.renderSlot("longpress-content");return this.longpressContent.length===0?e:s.x`
+      <luzmo-overlay
+        id="longpress-overlay"
+        ?disabled=${this.disabled||this.longpressContent.length===0}
+        ?open=${this.open==="longpress"&&this.longpressContent.length>0}
+        .offset=${this.offset}
+        .placement=${this.longpressPlacement||this.placement}
+        .triggerElement=${this.targetContent[0]}
+        .triggerInteraction=${"longpress"}
+        .type=${"auto"}
+        @beforetoggle=${this.handleBeforetoggle}
+        .receivesFocus=${this.receivesFocus}
+      >
+        ${e}
+      </luzmo-overlay>
+      <slot name="longpress-describedby-descriptor"></slot>
+    `}render(){const e=this.content.split(" ");return s.x`
+      <slot
+        id="trigger"
+        name="trigger"
+        @slotchange=${this.handleTriggerContent}
+      ></slot>
+      ${[e.includes("click")?this.renderClickOverlay():s.x``,e.includes("hover")?this.renderHoverOverlay():s.x``,e.includes("longpress")?this.renderLongpressOverlay():s.x``]}
+    `}updated(e){if(super.updated(e),this.disabled&&e.has("disabled")){this.open=void 0;return}}async getUpdateComplete(){return await super.getUpdateComplete()}}l([s.n()],o.prototype,"content");l([s.n({reflect:!0})],o.prototype,"placement");l([s.n()],o.prototype,"type");l([s.n({type:Number})],o.prototype,"offset");l([s.n({reflect:!0})],o.prototype,"open");l([s.n({type:Boolean,reflect:!0})],o.prototype,"disabled");l([s.n({attribute:"receives-focus"})],o.prototype,"receivesFocus");l([p.r()],o.prototype,"clickContent");l([p.r()],o.prototype,"longpressContent");l([p.r()],o.prototype,"hoverContent");l([p.r()],o.prototype,"targetContent");l([u.e("#click-overlay",!0)],o.prototype,"clickOverlayElement");l([u.e("#longpress-overlay",!0)],o.prototype,"longpressOverlayElement");l([u.e("#hover-overlay",!0)],o.prototype,"hoverOverlayElement");function k(c,e,t,r){return n.Overlay.open(c,e,t,r)}class v extends O.f{render(e){return s.E}update(e,[t]){this.template=t,this.target!==e.element&&(this.target=e.element,this.renderBefore=this.target.children[0]),this.listenerHost=this.target,this.init()}handleSlottableRequest(e){if(e.target!==e.currentTarget)return;const t=e.data===d.removeSlottableRequest;s.B(t?void 0:this.template(),this.target,{renderBefore:this.renderBefore})}init(){var t;(t=this.listeners)==null||t.abort(),this.listeners=new AbortController;const{signal:e}=this.listeners;this.listenerHost.addEventListener("slottable-request",r=>this.handleSlottableRequest(r),{signal:e})}disconnected(){var e;(e=this.listeners)==null||e.abort()}reconnected(){this.init()}}const E=f.e(v);class b extends v{constructor(){super(...arguments),this.defaultOptions={triggerInteraction:"click",overlayOptions:{type:"auto",offset:0}},this.options={...this.defaultOptions.overlayOptions}}render(e,t){return s.E}update(e,[t,r]){var g,y,m;this.options={...this.defaultOptions.overlayOptions,...r==null?void 0:r.overlayOptions},this.insertionOptions=r==null?void 0:r.insertionOptions,this.template=t,this.host=(g=e.options)==null?void 0:g.host;let i=!1;const a=(r==null?void 0:r.triggerInteraction)||this.defaultOptions.triggerInteraction,h=n.InteractionTypes[(y=this.strategy)==null?void 0:y.type]!==a;this.target!==e.element&&(this.target=e.element,i=!0),(i||h)&&((m=this.strategy)==null||m.abort(),this.strategy=new n.strategies[a](this.target,{isPersistent:!0,handleOverlayReady:C=>{this.listenerHost=this.overlay=C,this.init()}})),this.strategy.open=(r==null?void 0:r.open)??!1}handleSlottableRequest(e){var i,a;if(e.target!==e.currentTarget)return;const t=e.data===d.removeSlottableRequest,r={};if(this.host&&(r.host=this.host),s.B(t?void 0:this.template(),this.overlay,r),t)this.overlay.remove();else{n.AbstractOverlay.applyOptions(this.overlay,{...this.options,trigger:this.target});const h=typeof((i=this.insertionOptions)==null?void 0:i.el)=="function"?this.insertionOptions.el():((a=this.insertionOptions)==null?void 0:a.el)||this.target,{where:g="afterend"}=this.insertionOptions||{};h.insertAdjacentElement(g,this.overlay)}}}const q=f.e(b);customElements.get("luzmo-overlay")||customElements.define("luzmo-overlay",n.Overlay);customElements.get("luzmo-overlay-trigger")||customElements.define("luzmo-overlay-trigger",o);exports.AbstractOverlay=n.AbstractOverlay;exports.ClickController=n.ClickController;exports.HoverController=n.HoverController;exports.InteractionController=n.InteractionController;exports.InteractionTypes=n.InteractionTypes;exports.LONGPRESS_INSTRUCTIONS=n.LONGPRESS_INSTRUCTIONS;exports.LongpressController=n.LongpressController;exports.Overlay=n.Overlay;exports.PlacementController=n.PlacementController;exports.VirtualTrigger=n.VirtualTrigger;exports.guaranteedAllTransitionend=n.guaranteedAllTransitionend;exports.nextFrame=n.nextFrame;exports.noop=n.noop;exports.overlayTimer=n.overlayTimer;exports.placementUpdatedSymbol=n.placementUpdatedSymbol;exports.SlottableRequestEvent=d.SlottableRequestEvent;exports.removeSlottableRequest=d.removeSlottableRequest;exports.OverlayTrigger=o;exports.OverlayTriggerDirective=b;exports.SlottableRequestDirective=v;exports.openOverlay=k;exports.slottableRequest=E;exports.trigger=q;

package/components/overlay/index.d.ts

@@ -0,0 +1,22 @@
+import { Overlay } from './overlay';
+import { OverlayTrigger } from './overlay-trigger';
+export * from './abstract-overlay';
+export * from './click-controller';
+export * from './hover-controller';
+export * from './interaction-controller';
+export * from './loader';
+export * from './longpress-controller';
+export * from './overlay';
+export * from './overlay-trigger';
+export * from './overlay-trigger-directive';
+export * from './overlay-types';
+export * from './placement-controller';
+export * from './slottable-request-directive';
+export * from './slottable-request-event';
+export * from './virtual-trigger';
+declare global {
+    interface HTMLElementTagNameMap {
+        'luzmo-overlay': Overlay;
+        'luzmo-overlay-trigger': OverlayTrigger;
+    }
+}