@rdlabo/ionic-theme-ios27 0.1.0-0

package/dist/popover/utils.d.ts

@@ -0,0 +1,37 @@
+import type { PopoverSize, PositionAlign, PositionReference, PositionSide, TriggerAction } from './popover-interface';
+export interface ReferenceCoordinates {
+    top: number;
+    left: number;
+    width: number;
+    height: number;
+}
+interface PopoverPosition {
+    top: number;
+    left: number;
+    referenceCoordinates?: ReferenceCoordinates;
+    originX: string;
+    originY: string;
+}
+export interface PopoverStyles {
+    top: number;
+    left: number;
+    bottom?: number;
+    originX: string;
+    originY: string;
+    checkSafeAreaLeft: boolean;
+    checkSafeAreaRight: boolean;
+    addPopoverBottomClass: boolean;
+}
+export declare const getPopoverDimensions: (size: PopoverSize, contentEl: HTMLElement, triggerEl?: HTMLElement) => {
+    contentWidth: number;
+    contentHeight: number;
+};
+export declare const configureDismissInteraction: (triggerEl: HTMLElement, triggerAction: TriggerAction, popoverEl: HTMLIonPopoverElement, parentPopoverEl: HTMLIonPopoverElement) => () => void;
+export declare const configureTriggerInteraction: (triggerEl: HTMLElement, triggerAction: TriggerAction, popoverEl: HTMLIonPopoverElement) => () => void;
+export declare const getIndexOfItem: (items: HTMLIonItemElement[], item: HTMLElement | null) => number;
+export declare const getNextItem: (items: HTMLIonItemElement[], currentItem: HTMLElement | null) => HTMLIonItemElement;
+export declare const getPrevItem: (items: HTMLIonItemElement[], currentItem: HTMLElement | null) => HTMLIonItemElement;
+export declare const getPopoverPosition: (isRTL: boolean, contentWidth: number, contentHeight: number, reference: PositionReference, side: PositionSide, align: PositionAlign, defaultPosition: PopoverPosition, triggerEl?: HTMLElement, event?: MouseEvent | CustomEvent) => PopoverPosition;
+export declare const calculateWindowAdjustment: (side: PositionSide, coordTop: number, coordLeft: number, bodyPadding: number, bodyWidth: number, bodyHeight: number, contentWidth: number, contentHeight: number, safeAreaMargin: number, contentOriginX: string, contentOriginY: string, triggerCoordinates?: ReferenceCoordinates, eventElementRect?: DOMRect, isReplace?: boolean) => PopoverStyles;
+export {};
+//# sourceMappingURL=utils.d.ts.map

package/dist/popover/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/popover/utils.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,iBAAiB,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAQtH,MAAM,WAAW,oBAAoB;IACnC,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,UAAU,eAAe;IACvB,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,oBAAoB,CAAC,EAAE,oBAAoB,CAAC;IAC5C,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,aAAa;IAC5B,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,iBAAiB,EAAE,OAAO,CAAC;IAC3B,kBAAkB,EAAE,OAAO,CAAC;IAC5B,qBAAqB,EAAE,OAAO,CAAC;CAChC;AAOD,eAAO,MAAM,oBAAoB,GAAI,MAAM,WAAW,EAAE,WAAW,WAAW,EAAE,YAAY,WAAW;;;CActG,CAAC;AAEF,eAAO,MAAM,2BAA2B,GACtC,WAAW,WAAW,EACtB,eAAe,aAAa,EAC5B,WAAW,qBAAqB,EAChC,iBAAiB,qBAAqB,eAyEvC,CAAC;AAOF,eAAO,MAAM,2BAA2B,GAAI,WAAW,WAAW,EAAE,eAAe,aAAa,EAAE,WAAW,qBAAqB,eA4HjI,CAAC;AAKF,eAAO,MAAM,cAAc,GAAI,OAAO,kBAAkB,EAAE,EAAE,MAAM,WAAW,GAAG,IAAI,WAMnF,CAAC;AAOF,eAAO,MAAM,WAAW,GAAI,OAAO,kBAAkB,EAAE,EAAE,aAAa,WAAW,GAAG,IAAI,uBAGvF,CAAC;AAOF,eAAO,MAAM,WAAW,GAAI,OAAO,kBAAkB,EAAE,EAAE,aAAa,WAAW,GAAG,IAAI,uBAGvF,CAAC;AAiBF,eAAO,MAAM,kBAAkB,GAC7B,OAAO,OAAO,EACd,cAAc,MAAM,EACpB,eAAe,MAAM,EACrB,WAAW,iBAAiB,EAC5B,MAAM,YAAY,EAClB,OAAO,aAAa,EACpB,iBAAiB,eAAe,EAChC,YAAY,WAAW,EACvB,QAAQ,UAAU,GAAG,WAAW,KAC/B,eAqFF,CAAC;AA6LF,eAAO,MAAM,yBAAyB,GACpC,MAAM,YAAY,EAClB,UAAU,MAAM,EAChB,WAAW,MAAM,EACjB,aAAa,MAAM,EACnB,WAAW,MAAM,EACjB,YAAY,MAAM,EAClB,cAAc,MAAM,EACpB,eAAe,MAAM,EACrB,gBAAgB,MAAM,EACtB,gBAAgB,MAAM,EACtB,gBAAgB,MAAM,EACtB,qBAAqB,oBAAoB,EACzC,mBAAmB,OAAO,EAC1B,YAAW,OAAe,KACzB,aAmFF,CAAC"}

package/dist/popover/utils.js

@@ -0,0 +1,377 @@
+import { getElementRoot, raf } from '../utils';
+import { POPOVER_IOS_BODY_MARGIN } from './animations/ios.enter';
+export const getPopoverDimensions = (size, contentEl, triggerEl) => {
+    const contentDimentions = contentEl.getBoundingClientRect();
+    const contentHeight = contentDimentions.height;
+    let contentWidth = contentDimentions.width;
+    if (size === 'cover' && triggerEl) {
+        const triggerDimensions = triggerEl.getBoundingClientRect();
+        contentWidth = triggerDimensions.width;
+    }
+    return {
+        contentWidth,
+        contentHeight,
+    };
+};
+export const configureDismissInteraction = (triggerEl, triggerAction, popoverEl, parentPopoverEl) => {
+    let dismissCallbacks = [];
+    const root = getElementRoot(parentPopoverEl);
+    const parentContentEl = root.querySelector('.popover-content');
+    switch (triggerAction) {
+        case 'hover':
+            dismissCallbacks = [
+                {
+                    eventName: 'mouseenter',
+                    callback: (ev) => {
+                        const element = document.elementFromPoint(ev.clientX, ev.clientY);
+                        if (element === triggerEl) {
+                            return;
+                        }
+                        popoverEl.dismiss(undefined, undefined, false);
+                    },
+                },
+            ];
+            break;
+        case 'context-menu':
+        case 'click':
+        default:
+            dismissCallbacks = [
+                {
+                    eventName: 'click',
+                    callback: (ev) => {
+                        const target = ev.target;
+                        const closestTrigger = target.closest('[data-ion-popover-trigger]');
+                        if (closestTrigger === triggerEl) {
+                            ev.stopPropagation();
+                            return;
+                        }
+                        popoverEl.dismiss(undefined, undefined, false);
+                    },
+                },
+            ];
+            break;
+    }
+    dismissCallbacks.forEach(({ eventName, callback }) => parentContentEl.addEventListener(eventName, callback));
+    return () => {
+        dismissCallbacks.forEach(({ eventName, callback }) => parentContentEl.removeEventListener(eventName, callback));
+    };
+};
+export const configureTriggerInteraction = (triggerEl, triggerAction, popoverEl) => {
+    let triggerCallbacks = [];
+    switch (triggerAction) {
+        case 'hover':
+            let hoverTimeout;
+            triggerCallbacks = [
+                {
+                    eventName: 'mouseenter',
+                    callback: async (ev) => {
+                        ev.stopPropagation();
+                        if (hoverTimeout) {
+                            clearTimeout(hoverTimeout);
+                        }
+                        hoverTimeout = setTimeout(() => {
+                            raf(() => {
+                                popoverEl.presentFromTrigger(ev);
+                                hoverTimeout = undefined;
+                            });
+                        }, 100);
+                    },
+                },
+                {
+                    eventName: 'mouseleave',
+                    callback: (ev) => {
+                        if (hoverTimeout) {
+                            clearTimeout(hoverTimeout);
+                        }
+                        const target = ev.relatedTarget;
+                        if (!target) {
+                            return;
+                        }
+                        if (target.closest('ion-popover') !== popoverEl) {
+                            popoverEl.dismiss(undefined, undefined, false);
+                        }
+                    },
+                },
+                {
+                    eventName: 'click',
+                    callback: (ev) => ev.stopPropagation(),
+                },
+                {
+                    eventName: 'ionPopoverActivateTrigger',
+                    callback: (ev) => popoverEl.presentFromTrigger(ev, true),
+                },
+            ];
+            break;
+        case 'context-menu':
+            triggerCallbacks = [
+                {
+                    eventName: 'contextmenu',
+                    callback: (ev) => {
+                        ev.preventDefault();
+                        popoverEl.presentFromTrigger(ev);
+                    },
+                },
+                {
+                    eventName: 'click',
+                    callback: (ev) => ev.stopPropagation(),
+                },
+                {
+                    eventName: 'ionPopoverActivateTrigger',
+                    callback: (ev) => popoverEl.presentFromTrigger(ev, true),
+                },
+            ];
+            break;
+        case 'click':
+        default:
+            triggerCallbacks = [
+                {
+                    eventName: 'click',
+                    callback: (ev) => popoverEl.presentFromTrigger(ev),
+                },
+                {
+                    eventName: 'ionPopoverActivateTrigger',
+                    callback: (ev) => popoverEl.presentFromTrigger(ev, true),
+                },
+            ];
+            break;
+    }
+    triggerCallbacks.forEach(({ eventName, callback }) => triggerEl.addEventListener(eventName, callback));
+    triggerEl.setAttribute('data-ion-popover-trigger', 'true');
+    return () => {
+        triggerCallbacks.forEach(({ eventName, callback }) => triggerEl.removeEventListener(eventName, callback));
+        triggerEl.removeAttribute('data-ion-popover-trigger');
+    };
+};
+export const getIndexOfItem = (items, item) => {
+    if (!item || item.tagName !== 'ION-ITEM') {
+        return -1;
+    }
+    return items.findIndex((el) => el === item);
+};
+export const getNextItem = (items, currentItem) => {
+    const currentItemIndex = getIndexOfItem(items, currentItem);
+    return items[currentItemIndex + 1];
+};
+export const getPrevItem = (items, currentItem) => {
+    const currentItemIndex = getIndexOfItem(items, currentItem);
+    return items[currentItemIndex - 1];
+};
+const focusItem = (item) => {
+    const root = getElementRoot(item);
+    const button = root.querySelector('button');
+    if (button) {
+        raf(() => button.focus());
+    }
+};
+export const getPopoverPosition = (isRTL, contentWidth, contentHeight, reference, side, align, defaultPosition, triggerEl, event) => {
+    let referenceCoordinates = {
+        top: 0,
+        left: 0,
+        width: 0,
+        height: 0,
+    };
+    switch (reference) {
+        case 'event':
+            if (!event) {
+                return defaultPosition;
+            }
+            const mouseEv = event;
+            referenceCoordinates = {
+                top: mouseEv.clientY,
+                left: mouseEv.clientX,
+                width: 1,
+                height: 1,
+            };
+            break;
+        case 'trigger':
+        default:
+            const customEv = event;
+            const actualTriggerEl = (triggerEl || customEv?.detail?.ionShadowTarget || customEv?.target);
+            if (!actualTriggerEl) {
+                return defaultPosition;
+            }
+            const triggerBoundingBox = actualTriggerEl.getBoundingClientRect();
+            referenceCoordinates = {
+                top: triggerBoundingBox.top,
+                left: triggerBoundingBox.left,
+                width: triggerBoundingBox.width,
+                height: triggerBoundingBox.height,
+            };
+            break;
+    }
+    const coordinates = calculatePopoverSide(side, referenceCoordinates, contentWidth, contentHeight, isRTL);
+    const alignedCoordinates = calculatePopoverAlign(align, side, referenceCoordinates, contentWidth, contentHeight);
+    const top = coordinates.top + alignedCoordinates.top;
+    const left = coordinates.left + alignedCoordinates.left;
+    const { originX, originY } = calculatePopoverOrigin(side, align, isRTL);
+    return { top, left, referenceCoordinates, originX, originY };
+};
+const calculatePopoverOrigin = (side, align, isRTL) => {
+    switch (side) {
+        case 'top':
+            return { originX: getOriginXAlignment(align), originY: 'bottom' };
+        case 'bottom':
+            return { originX: getOriginXAlignment(align), originY: 'top' };
+        case 'left':
+            return { originX: 'right', originY: getOriginYAlignment(align) };
+        case 'right':
+            return { originX: 'left', originY: getOriginYAlignment(align) };
+        case 'start':
+            return { originX: isRTL ? 'left' : 'right', originY: getOriginYAlignment(align) };
+        case 'end':
+            return { originX: isRTL ? 'right' : 'left', originY: getOriginYAlignment(align) };
+    }
+};
+const getOriginXAlignment = (align) => {
+    switch (align) {
+        case 'start':
+            return 'left';
+        case 'center':
+            return 'center';
+        case 'end':
+            return 'right';
+    }
+};
+const getOriginYAlignment = (align) => {
+    switch (align) {
+        case 'start':
+            return 'top';
+        case 'center':
+            return 'center';
+        case 'end':
+            return 'bottom';
+    }
+};
+const calculatePopoverSide = (side, triggerBoundingBox, contentWidth, contentHeight, isRTL) => {
+    const sideLeft = {
+        top: triggerBoundingBox.top,
+        left: triggerBoundingBox.left - contentWidth,
+    };
+    const sideRight = {
+        top: triggerBoundingBox.top,
+        left: triggerBoundingBox.left + triggerBoundingBox.width,
+    };
+    switch (side) {
+        case 'top':
+            return {
+                top: triggerBoundingBox.top - contentHeight,
+                left: triggerBoundingBox.left,
+            };
+        case 'right':
+            return sideRight;
+        case 'bottom':
+            return {
+                top: triggerBoundingBox.top + triggerBoundingBox.height,
+                left: triggerBoundingBox.left,
+            };
+        case 'left':
+            return sideLeft;
+        case 'start':
+            return isRTL ? sideRight : sideLeft;
+        case 'end':
+            return isRTL ? sideLeft : sideRight;
+    }
+};
+const calculatePopoverAlign = (align, side, triggerBoundingBox, contentWidth, contentHeight) => {
+    switch (align) {
+        case 'center':
+            return calculatePopoverCenterAlign(side, triggerBoundingBox, contentWidth, contentHeight);
+        case 'end':
+            return calculatePopoverEndAlign(side, triggerBoundingBox, contentWidth, contentHeight);
+        case 'start':
+        default:
+            return { top: 0, left: 0 };
+    }
+};
+const calculatePopoverEndAlign = (side, triggerBoundingBox, contentWidth, contentHeight) => {
+    switch (side) {
+        case 'start':
+        case 'end':
+        case 'left':
+        case 'right':
+            return {
+                top: -(contentHeight - triggerBoundingBox.height),
+                left: 0,
+            };
+        case 'top':
+        case 'bottom':
+        default:
+            return {
+                top: 0,
+                left: -(contentWidth - triggerBoundingBox.width),
+            };
+    }
+};
+const calculatePopoverCenterAlign = (side, triggerBoundingBox, contentWidth, contentHeight) => {
+    switch (side) {
+        case 'start':
+        case 'end':
+        case 'left':
+        case 'right':
+            return {
+                top: -(contentHeight / 2 - triggerBoundingBox.height / 2),
+                left: 0,
+            };
+        case 'top':
+        case 'bottom':
+        default:
+            return {
+                top: 0,
+                left: -(contentWidth / 2 - triggerBoundingBox.width / 2),
+            };
+    }
+};
+export const calculateWindowAdjustment = (side, coordTop, coordLeft, bodyPadding, bodyWidth, bodyHeight, contentWidth, contentHeight, safeAreaMargin, contentOriginX, contentOriginY, triggerCoordinates, eventElementRect, isReplace = false) => {
+    const triggerTop = triggerCoordinates ? triggerCoordinates.top + triggerCoordinates.height : bodyHeight / 2 - contentHeight / 2;
+    const triggerHeight = triggerCoordinates ? triggerCoordinates.height : 0;
+    let left = coordLeft;
+    let top = !isReplace ? coordTop + POPOVER_IOS_BODY_MARGIN : coordTop - triggerHeight;
+    let bottom;
+    let originX = contentOriginX;
+    let originY = contentOriginY;
+    let checkSafeAreaLeft = false;
+    let checkSafeAreaRight = false;
+    let addPopoverBottomClass = false;
+    if (left < bodyPadding + safeAreaMargin) {
+        left = !eventElementRect ? bodyPadding : eventElementRect.left;
+        if (left === 0) {
+            left = safeAreaMargin;
+        }
+        checkSafeAreaLeft = true;
+        originX = 'left';
+    }
+    else if (contentWidth + bodyPadding + left + safeAreaMargin > bodyWidth) {
+        checkSafeAreaRight = true;
+        left = !eventElementRect ? bodyWidth - contentWidth - bodyPadding : eventElementRect.right - contentWidth;
+        if (left + contentWidth === bodyWidth) {
+            left = left - safeAreaMargin;
+        }
+        originX = 'right';
+    }
+    const compareTop = triggerCoordinates ? triggerCoordinates.top + triggerCoordinates.height / 2 : bodyHeight / 2 - contentHeight / 2;
+    if (compareTop > bodyHeight / 2 && (side === 'top' || side === 'bottom')) {
+        if (triggerTop - contentHeight > 0) {
+            if (!isReplace) {
+                top = Math.max(12, triggerTop - contentHeight - triggerHeight) - POPOVER_IOS_BODY_MARGIN;
+            }
+            else {
+                top = Math.max(12, triggerTop - contentHeight);
+            }
+            originY = 'bottom';
+            addPopoverBottomClass = true;
+        }
+        else {
+            bottom = bodyPadding;
+        }
+    }
+    return {
+        top,
+        left,
+        bottom,
+        originX,
+        originY,
+        checkSafeAreaLeft,
+        checkSafeAreaRight,
+        addPopoverBottomClass,
+    };
+};

package/dist/sheets-of-glass/animations.d.ts

@@ -0,0 +1,8 @@
+import type { Animation, AnimationKeyFrames } from '@ionic/core';
+import { AnimationPosition, EffectScales } from './interfaces';
+import { GestureDetail } from '@ionic/core';
+export declare const getScaleAnimation: (effectElement: Element) => Animation;
+export declare const createPreMoveAnimation: (effectElement: Element, tabSelectedElement: Element, currentTouchedElement: Element, animationPosition: AnimationPosition) => Animation;
+export declare const createMoveAnimation: (effectElement: Element, detail: GestureDetail, tabSelectedElement: Element, animationPosition: AnimationPosition) => Animation;
+export declare const getMoveAnimationKeyframe: (type: "moveRight" | "moveLeft" | "slowly", scales: EffectScales) => AnimationKeyFrames;
+//# sourceMappingURL=animations.d.ts.map

package/dist/sheets-of-glass/animations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"animations.d.ts","sourceRoot":"","sources":["../../src/sheets-of-glass/animations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACjE,OAAO,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAC/D,OAAO,EAAmB,aAAa,EAAE,MAAM,aAAa,CAAC;AAG7D,eAAO,MAAM,iBAAiB,GAAI,eAAe,OAAO,KAAG,SAE1D,CAAC;AAEF,eAAO,MAAM,sBAAsB,GACjC,eAAe,OAAO,EACtB,oBAAoB,OAAO,EAC3B,uBAAuB,OAAO,EAC9B,mBAAmB,iBAAiB,KACnC,SA0BF,CAAC;AAEF,eAAO,MAAM,mBAAmB,GAC9B,eAAe,OAAO,EACtB,QAAQ,aAAa,EACrB,oBAAoB,OAAO,EAC3B,mBAAmB,iBAAiB,KACnC,SAiBF,CAAC;AAEF,eAAO,MAAM,wBAAwB,GAAI,MAAM,WAAW,GAAG,UAAU,GAAG,QAAQ,EAAE,QAAQ,YAAY,KAAG,kBAqD1G,CAAC"}

package/dist/sheets-of-glass/animations.js

@@ -0,0 +1,97 @@
+import { createAnimation } from '@ionic/core';
+import { getStep } from '../utils';
+export const getScaleAnimation = (effectElement) => {
+    return createAnimation().addElement(effectElement.shadowRoot.querySelector('[part="native"]')).easing('ease-out');
+};
+export const createPreMoveAnimation = (effectElement, tabSelectedElement, currentTouchedElement, animationPosition) => {
+    const diff = Math.max(Math.abs(tabSelectedElement.getBoundingClientRect().left - currentTouchedElement.getBoundingClientRect().left), 140);
+    return createAnimation()
+        .duration(diff * 2.1)
+        .easing('ease-out')
+        .addElement(effectElement)
+        .beforeStyles({
+        width: `${tabSelectedElement.clientWidth}px`,
+        height: `${tabSelectedElement.clientHeight}px`,
+        display: 'block',
+        opacity: '1',
+        transform: 'none',
+    })
+        .keyframes([
+        {
+            offset: 0,
+            transform: `translate3d(${tabSelectedElement.getBoundingClientRect().left}px,  ${animationPosition.positionY}px, 0)`,
+        },
+        {
+            offset: 1,
+            transform: `translate3d(${currentTouchedElement.getBoundingClientRect().left}px,  ${animationPosition.positionY}px, 0)`,
+        },
+    ]);
+};
+export const createMoveAnimation = (effectElement, detail, tabSelectedElement, animationPosition) => {
+    return createAnimation()
+        .duration(500)
+        .addElement(effectElement)
+        .beforeStyles({
+        width: `${tabSelectedElement.clientWidth}px`,
+        height: `${tabSelectedElement.clientHeight}px`,
+        display: 'block',
+        opacity: '1',
+        transform: 'none',
+    })
+        .fromTo('transform', `translate3d(${animationPosition.minPositionX}px, ${animationPosition.positionY}px, 0)`, `translate3d(${animationPosition.maxPositionX}px, ${animationPosition.positionY}px, 0)`)
+        .progressStep(getStep(detail.currentX, animationPosition));
+};
+export const getMoveAnimationKeyframe = (type, scales) => {
+    return {
+        moveRight: [
+            {
+                offset: 0,
+                transform: scales.large,
+            },
+            {
+                offset: 0.4,
+                transform: scales.small,
+            },
+            {
+                offset: 0.75,
+                transform: scales.xlarge,
+            },
+            {
+                offset: 1,
+                transform: scales.large,
+            },
+        ],
+        moveLeft: [
+            {
+                offset: 0,
+                transform: scales.large,
+            },
+            {
+                offset: 0.1,
+                transform: scales.xlarge,
+            },
+            {
+                offset: 0.6,
+                transform: scales.small,
+            },
+            {
+                offset: 1,
+                transform: scales.large,
+            },
+        ],
+        slowly: [
+            {
+                offset: 0,
+                transform: scales.large,
+            },
+            {
+                offset: 0.4,
+                transform: scales.medium,
+            },
+            {
+                offset: 1,
+                transform: scales.large,
+            },
+        ],
+    }[type];
+};

package/dist/sheets-of-glass/index.d.ts

@@ -0,0 +1,3 @@
+import { EffectScales, registeredEffect } from './interfaces';
+export declare const registerEffect: (targetElement: HTMLElement, effectTagName: string, selectedClassName: string, scales: EffectScales) => registeredEffect | undefined;
+//# sourceMappingURL=index.d.ts.map

package/dist/sheets-of-glass/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/sheets-of-glass/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqB,YAAY,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AASjF,eAAO,MAAM,cAAc,GACzB,eAAe,WAAW,EAC1B,eAAe,MAAM,EACrB,mBAAmB,MAAM,EACzB,QAAQ,YAAY,KACnB,gBAAgB,GAAG,SAuMrB,CAAC"}