lapikit 0.5.9 → 0.6.0

package/dist/@legacy/internal/core/actions/assets.svelte.js

@@ -1,54 +0,0 @@
-import { x11ColorNames } from '../x11-colors.js';
-export function getAssets() {
-    return {
-        shape(params) {
-            if (params) {
-                if (params === 'none' || params == '0')
-                    return '0';
-                return `var(--system-shape-${params})`;
-            }
-        },
-        className(key, type, value) {
-            if (typeof value === 'string')
-                return `kit-${key}--${type}-${value}`;
-            else if (typeof value === 'boolean' && value)
-                return `kit-${key}--${type}`;
-            else if (typeof value === 'object') {
-                if (Array.isArray(value)) {
-                    return value
-                        .map((media) => `${media === 'base' ? '' : `${media}:`}kit--${type}`)
-                        .join(' ');
-                }
-                else {
-                    return Object.entries(value)
-                        .map(([media, value]) => `${media === 'base' ? '' : `${media}:`}kit-${key}--${type}-${value}`)
-                        .join(' ');
-                }
-            }
-        },
-        color(color) {
-            if (color) {
-                if (color.includes('#') ||
-                    color.includes('rgb') ||
-                    color.includes('rgba') ||
-                    color.includes('oklch') ||
-                    x11ColorNames.includes(color.toLowerCase()))
-                    return color;
-                if (color.includes('transparent') || color.includes('inherit') || color.includes('initial'))
-                    return color;
-                return `var(--kit-${color})`;
-            }
-        },
-        unit(value) {
-            if (typeof value === 'number')
-                return `${value}px`;
-            if (typeof value === 'string') {
-                const cleaned = value.trim();
-                const isOnlyNumericLike = /^[\d.,]+$/.test(cleaned);
-                if (isOnlyNumericLike)
-                    return `${value}px`;
-            }
-            return value;
-        }
-    };
-}

package/dist/@legacy/internal/core/actions/dropdown.svelte.d.ts

@@ -1,7 +0,0 @@
-import type { PositionElement } from '../../../components/dropdown/types.js';
-type Location = 'top' | 'bottom' | 'left' | 'right';
-export declare function getPositions(): {
-    readonly values: PositionElement;
-    update(activator: HTMLElement | PointerEvent, element: HTMLElement, location?: Location, centered?: boolean, avoidCollisions?: boolean): void;
-};
-export {};

package/dist/@legacy/internal/core/actions/dropdown.svelte.js

@@ -1,148 +0,0 @@
-import { innerWidth, innerHeight } from 'svelte/reactivity/window';
-export function getPositions() {
-    // state
-    const axis = $state({
-        x: 0,
-        y: 0,
-        location: null
-    });
-    return {
-        get values() {
-            return axis;
-        },
-        update(activator, element, location, centered, avoidCollisions) {
-            if (!activator || !element)
-                return;
-            const elementRect = element.getBoundingClientRect();
-            if (!(activator instanceof HTMLElement)) {
-                if (activator.clientX + elementRect.width > innerWidth.current) {
-                    axis.x = activator.clientX - elementRect.width;
-                }
-                else {
-                    axis.x = activator.clientX;
-                }
-                if (activator.clientY + elementRect.height > innerHeight.current) {
-                    axis.y = activator.clientY - elementRect.height;
-                }
-                else {
-                    axis.y = activator.clientY;
-                }
-            }
-            else if (activator instanceof HTMLElement) {
-                const activatorRect = activator.getBoundingClientRect();
-                const spacing = 0;
-                const _activator = activatorRect.y + activatorRect.height;
-                const _element = elementRect.height + spacing;
-                if (location === 'top' || location === 'bottom') {
-                    if (avoidCollisions) {
-                        if (location === 'top') {
-                            if (activatorRect.y - _element < 0) {
-                                axis.y = activatorRect.bottom + spacing;
-                                axis.location = 'bottom';
-                            }
-                            else {
-                                axis.y = activatorRect.top - _element;
-                                axis.location = 'top';
-                            }
-                        }
-                        else {
-                            if (_activator + _element > innerHeight.current) {
-                                axis.y = activatorRect.top - _element;
-                                axis.location = 'top';
-                            }
-                            else {
-                                axis.y = activatorRect.bottom + spacing;
-                                axis.location = 'bottom';
-                            }
-                        }
-                    }
-                    else {
-                        if (location === 'top') {
-                            axis.y = activatorRect.top - _element;
-                            axis.location = 'top';
-                        }
-                        else {
-                            axis.y = activatorRect.bottom + spacing;
-                            axis.location = 'bottom';
-                        }
-                    }
-                    if (centered &&
-                        activatorRect.left - (elementRect.width - activatorRect.width) / 2 > 0 &&
-                        activatorRect.left + elementRect.width < innerWidth.current) {
-                        axis.x = activatorRect.left - (elementRect.width - activatorRect.width) / 2;
-                    }
-                    else if (activatorRect.left + elementRect.width > innerWidth.current) {
-                        axis.x = activatorRect.left - (elementRect.width - activatorRect.width);
-                    }
-                    else {
-                        axis.x = activatorRect.left;
-                    }
-                }
-                else if (location === 'left' || location === 'right') {
-                    if (avoidCollisions) {
-                        if (location === 'left' && !(activatorRect.left - elementRect.width < 0)) {
-                            axis.x = activatorRect.left - (elementRect.width + spacing);
-                            axis.location = 'left';
-                        }
-                        else {
-                            if (activatorRect.left + activatorRect.width + elementRect.width + spacing >
-                                innerWidth.current) {
-                                axis.x = activatorRect.left - (elementRect.width + spacing);
-                                axis.location = 'left';
-                            }
-                            else {
-                                axis.x = activatorRect.left + activatorRect.width + spacing;
-                                axis.location = 'right';
-                            }
-                        }
-                    }
-                    else {
-                        if (location === 'left') {
-                            axis.x = activatorRect.left - (elementRect.width + spacing);
-                            axis.location = 'left';
-                        }
-                        else {
-                            axis.x = activatorRect.left + activatorRect.width + spacing;
-                            axis.location = 'right';
-                        }
-                    }
-                    if (centered &&
-                        activatorRect.top - (elementRect.height - activatorRect.height) / 2 > 0 &&
-                        activatorRect.top + elementRect.height < innerHeight.current) {
-                        axis.y = activatorRect.top - (elementRect.height - activatorRect.height) / 2;
-                    }
-                    else if (activatorRect.y + elementRect.height > innerHeight.current) {
-                        axis.y = activatorRect.y - elementRect.height + activatorRect.height;
-                    }
-                    else {
-                        axis.y = activatorRect.y;
-                    }
-                }
-                else {
-                    if (centered &&
-                        activatorRect.left - (elementRect.width - activatorRect.width) / 2 > 0 &&
-                        activatorRect.left + elementRect.width < innerWidth.current) {
-                        axis.x = activatorRect.left - (elementRect.width - activatorRect.width) / 2;
-                    }
-                    else if (activatorRect.left + elementRect.width > innerWidth.current) {
-                        axis.x = activatorRect.left - (elementRect.width - activatorRect.width);
-                    }
-                    else {
-                        axis.x = activatorRect.left;
-                    }
-                    if (centered &&
-                        activatorRect.top - (elementRect.height - activatorRect.height) / 2 > 0 &&
-                        activatorRect.top + elementRect.height < innerHeight.current) {
-                        axis.y = activatorRect.top - (elementRect.height - activatorRect.height) / 2;
-                    }
-                    else if (activatorRect.bottom + elementRect.height > innerHeight.current) {
-                        axis.y = activatorRect.top - elementRect.height;
-                    }
-                    else {
-                        axis.y = activatorRect.bottom;
-                    }
-                }
-            }
-        }
-    };
-}

package/dist/@legacy/internal/core/actions/popover.svelte.d.ts

@@ -1,7 +0,0 @@
-import type { PositionElement } from '../../../components/popover/types.js';
-type Location = 'top' | 'bottom' | 'left' | 'right';
-export declare function getPositions(): {
-    readonly values: PositionElement;
-    update(activator: HTMLElement, element: HTMLElement, location?: Location, centered?: boolean, avoidCollisions?: boolean): void;
-};
-export {};

package/dist/@legacy/internal/core/actions/popover.svelte.js

@@ -1,134 +0,0 @@
-import { innerWidth, innerHeight } from 'svelte/reactivity/window';
-export function getPositions() {
-    // state
-    const axis = $state({
-        x: 0,
-        y: 0,
-        location: null
-    });
-    return {
-        get values() {
-            return axis;
-        },
-        update(activator, element, location, centered, avoidCollisions) {
-            if (!activator || !element)
-                return;
-            const elementRect = element.getBoundingClientRect();
-            if (activator instanceof HTMLElement) {
-                const activatorRect = activator.getBoundingClientRect();
-                const spacing = 6;
-                const _activator = activatorRect.y + activatorRect.height;
-                const _element = elementRect.height + spacing;
-                if (location === 'top' || location === 'bottom') {
-                    if (avoidCollisions) {
-                        if (location === 'top') {
-                            if (activatorRect.y - _element < 0) {
-                                axis.y = activatorRect.bottom + spacing;
-                                axis.location = 'bottom';
-                            }
-                            else {
-                                axis.y = activatorRect.top - _element;
-                                axis.location = 'top';
-                            }
-                        }
-                        else {
-                            if (_activator + _element > innerHeight.current) {
-                                axis.y = activatorRect.top - _element;
-                                axis.location = 'top';
-                            }
-                            else {
-                                axis.y = activatorRect.bottom + spacing;
-                                axis.location = 'bottom';
-                            }
-                        }
-                    }
-                    else {
-                        if (location === 'top') {
-                            axis.y = activatorRect.top - _element;
-                            axis.location = 'top';
-                        }
-                        else {
-                            axis.y = activatorRect.bottom + spacing;
-                            axis.location = 'bottom';
-                        }
-                    }
-                    if (centered &&
-                        activatorRect.left - (elementRect.width - activatorRect.width) / 2 > 0 &&
-                        activatorRect.left + elementRect.width < innerWidth.current) {
-                        axis.x = activatorRect.left - (elementRect.width - activatorRect.width) / 2;
-                    }
-                    else if (activatorRect.left + elementRect.width > innerWidth.current) {
-                        axis.x = activatorRect.left - (elementRect.width - activatorRect.width);
-                    }
-                    else {
-                        axis.x = activatorRect.left;
-                    }
-                }
-                else if (location === 'left' || location === 'right') {
-                    if (avoidCollisions) {
-                        if (location === 'left' && !(activatorRect.left - elementRect.width < 0)) {
-                            axis.x = activatorRect.left - (elementRect.width + spacing);
-                            axis.location = 'left';
-                        }
-                        else {
-                            if (activatorRect.left + activatorRect.width + elementRect.width + spacing >
-                                innerWidth.current) {
-                                axis.x = activatorRect.left - (elementRect.width + spacing);
-                                axis.location = 'left';
-                            }
-                            else {
-                                axis.x = activatorRect.left + activatorRect.width + spacing;
-                                axis.location = 'right';
-                            }
-                        }
-                    }
-                    else {
-                        if (location === 'left') {
-                            axis.x = activatorRect.left - (elementRect.width + spacing);
-                            axis.location = 'left';
-                        }
-                        else {
-                            axis.x = activatorRect.left + activatorRect.width + spacing;
-                            axis.location = 'right';
-                        }
-                    }
-                    if (centered &&
-                        activatorRect.top - (elementRect.height - activatorRect.height) / 2 > 0 &&
-                        activatorRect.top + elementRect.height < innerHeight.current) {
-                        axis.y = activatorRect.top - (elementRect.height - activatorRect.height) / 2;
-                    }
-                    else if (activatorRect.y + elementRect.height > innerHeight.current) {
-                        axis.y = activatorRect.y - elementRect.height + activatorRect.height;
-                    }
-                    else {
-                        axis.y = activatorRect.y;
-                    }
-                }
-                else {
-                    if (centered &&
-                        activatorRect.left - (elementRect.width - activatorRect.width) / 2 > 0 &&
-                        activatorRect.left + elementRect.width < innerWidth.current) {
-                        axis.x = activatorRect.left - (elementRect.width - activatorRect.width) / 2;
-                    }
-                    else if (activatorRect.left + elementRect.width > innerWidth.current) {
-                        axis.x = activatorRect.left - (elementRect.width - activatorRect.width);
-                    }
-                    else {
-                        axis.x = activatorRect.left;
-                    }
-                    if (centered &&
-                        activatorRect.top - (elementRect.height - activatorRect.height) / 2 > 0 &&
-                        activatorRect.top + elementRect.height < innerHeight.current) {
-                        axis.y = activatorRect.top - (elementRect.height - activatorRect.height) / 2;
-                    }
-                    else if (activatorRect.bottom + elementRect.height > innerHeight.current) {
-                        axis.y = activatorRect.top - elementRect.height;
-                    }
-                    else {
-                        axis.y = activatorRect.bottom;
-                    }
-                }
-            }
-        }
-    };
-}

package/dist/@legacy/internal/core/actions/tooltip.svelte.d.ts

@@ -1,7 +0,0 @@
-import type { PositionElement } from '../../../components/tooltip/types.js';
-type Location = 'top' | 'bottom' | 'left' | 'right';
-export declare function getPositionsTooltip(): {
-    readonly values: PositionElement;
-    update(activator: HTMLElement, element: HTMLElement, location?: Location, centered?: boolean, avoidCollisions?: boolean): void;
-};
-export {};

package/dist/@legacy/internal/core/actions/tooltip.svelte.js

@@ -1,131 +0,0 @@
-import { innerWidth, innerHeight } from 'svelte/reactivity/window';
-export function getPositionsTooltip() {
-    // state
-    const axis = $state({
-        x: 0,
-        y: 0,
-        location: null
-    });
-    return {
-        get values() {
-            return axis;
-        },
-        update(activator, element, location, centered, avoidCollisions) {
-            if (!activator || !element)
-                return;
-            const elementRect = element.getBoundingClientRect();
-            const activatorRect = activator.getBoundingClientRect();
-            const spacing = 6;
-            if (location === 'top' || location === 'bottom') {
-                if (avoidCollisions) {
-                    if (location === 'top') {
-                        if (activatorRect.y - (elementRect.height + spacing) < 0) {
-                            axis.y = activatorRect.bottom + spacing;
-                            axis.location = 'bottom';
-                        }
-                        else {
-                            axis.y = activatorRect.top - (elementRect.height + spacing);
-                            axis.location = 'top';
-                        }
-                    }
-                    else {
-                        if (activatorRect.y + activatorRect.height + (elementRect.height + spacing) >
-                            innerHeight.current) {
-                            axis.y = activatorRect.top - (elementRect.height + spacing);
-                            axis.location = 'top';
-                        }
-                        else {
-                            axis.y = activatorRect.bottom + spacing;
-                            axis.location = 'bottom';
-                        }
-                    }
-                }
-                else {
-                    if (location === 'top') {
-                        axis.y = activatorRect.top - (elementRect.height + spacing);
-                        axis.location = 'top';
-                    }
-                    else {
-                        axis.y = activatorRect.bottom + spacing;
-                        axis.location = 'bottom';
-                    }
-                }
-                if (centered &&
-                    activatorRect.left - (elementRect.width - activatorRect.width) / 2 > 0 &&
-                    activatorRect.left + elementRect.width < innerWidth.current) {
-                    axis.x = activatorRect.left - (elementRect.width - activatorRect.width) / 2;
-                }
-                else if (activatorRect.left + elementRect.width > innerWidth.current) {
-                    axis.x = activatorRect.left - (elementRect.width - activatorRect.width);
-                }
-                else {
-                    axis.x = activatorRect.left;
-                }
-            }
-            else if (location === 'left' || location === 'right') {
-                if (avoidCollisions) {
-                    if (location === 'left' && !(activatorRect.left - elementRect.width < 0)) {
-                        axis.x = activatorRect.left - (elementRect.width + spacing);
-                        axis.location = 'left';
-                    }
-                    else {
-                        if (activatorRect.left + activatorRect.width + elementRect.width + spacing >
-                            innerWidth.current) {
-                            axis.x = activatorRect.left - (elementRect.width + spacing);
-                            axis.location = 'left';
-                        }
-                        else {
-                            axis.x = activatorRect.left + activatorRect.width + spacing;
-                            axis.location = 'right';
-                        }
-                    }
-                }
-                else {
-                    if (location === 'left') {
-                        axis.x = activatorRect.left - (elementRect.width + spacing);
-                        axis.location = 'left';
-                    }
-                    else {
-                        axis.x = activatorRect.left + activatorRect.width + spacing;
-                        axis.location = 'right';
-                    }
-                }
-                if (centered &&
-                    activatorRect.top - (elementRect.height - activatorRect.height) / 2 > 0 &&
-                    activatorRect.top + elementRect.height < innerHeight.current) {
-                    axis.y = activatorRect.top - (elementRect.height - activatorRect.height) / 2;
-                }
-                else if (activatorRect.y + elementRect.height > innerHeight.current) {
-                    axis.y = activatorRect.y - elementRect.height + activatorRect.height;
-                }
-                else {
-                    axis.y = activatorRect.y;
-                }
-            }
-            else {
-                if (centered &&
-                    activatorRect.left - (elementRect.width - activatorRect.width) / 2 > 0 &&
-                    activatorRect.left + elementRect.width < innerWidth.current) {
-                    axis.x = activatorRect.left - (elementRect.width - activatorRect.width) / 2;
-                }
-                else if (activatorRect.left + elementRect.width > innerWidth.current) {
-                    axis.x = activatorRect.left - (elementRect.width - activatorRect.width);
-                }
-                else {
-                    axis.x = activatorRect.left;
-                }
-                if (centered &&
-                    activatorRect.top - (elementRect.height - activatorRect.height) / 2 > 0 &&
-                    activatorRect.top + elementRect.height < innerHeight.current) {
-                    axis.y = activatorRect.top - (elementRect.height - activatorRect.height) / 2;
-                }
-                else if (activatorRect.bottom + elementRect.height > innerHeight.current) {
-                    axis.y = activatorRect.top - elementRect.height;
-                }
-                else {
-                    axis.y = activatorRect.bottom;
-                }
-            }
-        }
-    };
-}

package/dist/@legacy/internal/core/animations/ripple.d.ts

@@ -1,12 +0,0 @@
-interface RippleOptions {
-    component?: string;
-    center?: boolean;
-    color?: string;
-    duration?: number;
-    disabled?: boolean;
-}
-export declare function ripple(el: HTMLElement, options?: RippleOptions): {
-    destroy(): void;
-    update(newOptions: RippleOptions): void;
-};
-export {};

package/dist/@legacy/internal/core/animations/ripple.js

@@ -1,96 +0,0 @@
-const triggerEvents = ['pointerdown', 'touchstart', 'keydown'];
-const cancelEvents = ['mouseleave', 'dragleave', 'touchmove', 'touchcancel', 'pointerup', 'keyup'];
-export function ripple(el, options = {}) {
-    const rippleContainer = document.createElement('div');
-    addClasses();
-    setOptions(options);
-    function isAriaDisabled() {
-        return el.getAttribute('aria-disabled') === 'true';
-    }
-    function addClasses(center) {
-        const shouldBeCentered = center || options.center;
-        if (!rippleContainer.classList.contains('kit-ripple--effect')) {
-            rippleContainer.classList.add('kit-ripple--effect');
-        }
-        if (!shouldBeCentered && rippleContainer.classList.contains('kit-ripple--center')) {
-            rippleContainer.classList.remove('kit-ripple--center');
-        }
-        if (shouldBeCentered) {
-            rippleContainer.classList.add('kit-ripple--center');
-        }
-    }
-    function setOptions(options) {
-        if (options.disabled || isAriaDisabled()) {
-            rippleContainer.remove();
-        }
-        else {
-            el.appendChild(rippleContainer);
-        }
-        if (options.duration && options.duration < 0) {
-            options.duration = undefined;
-        }
-        if (options.component) {
-            rippleContainer.style.setProperty('--system-ripple-radius', `var(--${options.component}-shape)`);
-        }
-        if (options.color) {
-            rippleContainer.style.setProperty('--system-ripple-color', options.color);
-        }
-        if (options.duration) {
-            rippleContainer.style.setProperty('--system-animation-ripple-duration', `${options.duration}ms`);
-        }
-    }
-    function createRipple(e, center) {
-        if (options.disabled || isAriaDisabled()) {
-            return;
-        }
-        if (e instanceof KeyboardEvent) {
-            if (!['Enter', 'Space'].includes(e.code) || e.repeat) {
-                return;
-            }
-            e.preventDefault();
-            const click = new PointerEvent('pointerdown');
-            createRipple(click, true);
-            return;
-        }
-        addClasses(center);
-        const rect = el.getBoundingClientRect();
-        const clientX = window.TouchEvent && e instanceof TouchEvent
-            ? e.touches[0].clientX
-            : e.clientX;
-        const clientY = window.TouchEvent && e instanceof TouchEvent
-            ? e.touches[0].clientY
-            : e.clientY;
-        const x = clientX - rect.left > el.offsetWidth / 2 ? 0 : el.offsetWidth;
-        const y = clientY - rect.top > el.offsetHeight / 2 ? 0 : el.offsetHeight;
-        const radius = Math.hypot(x - (clientX - rect.left), y - (clientY - rect.top));
-        const ripple = document.createElement('div');
-        ripple.classList.add('kit-ripple');
-        ripple.style.left = `${clientX - rect.left - radius}px`;
-        ripple.style.top = `${clientY - rect.top - radius}px`;
-        ripple.style.width = ripple.style.height = `${radius * 2}px`;
-        rippleContainer.appendChild(ripple);
-        function removeRipple() {
-            if (ripple === null) {
-                return;
-            }
-            ripple.style.opacity = '0';
-            setTimeout(() => {
-                ripple.remove();
-            }, options.duration || 1000);
-            cancelEvents.forEach((event) => el.removeEventListener(event, removeRipple));
-        }
-        cancelEvents.forEach((event) => el.addEventListener(event, removeRipple, { passive: true }));
-    }
-    triggerEvents.forEach((event) => el.addEventListener(event, createRipple, { passive: event === 'touchstart' }));
-    return {
-        destroy() {
-            triggerEvents.forEach((event) => {
-                el.removeEventListener(event, createRipple);
-            });
-        },
-        update(newOptions) {
-            options = newOptions;
-            setOptions(newOptions);
-        }
-    };
-}

package/dist/@legacy/internal/core/bin/ansi.d.ts

@@ -1,40 +0,0 @@
-export declare const ansi: {
-    color: {
-        red: (text: string) => string;
-        green: (text: string) => string;
-        yellow: (text: string) => string;
-        blue: (text: string) => string;
-        purple: (text: string) => string;
-        cyan: (text: string) => string;
-    };
-    variant: {
-        bold: (text: string) => string;
-        underline: (text: string) => string;
-        inverse: (text: string) => string;
-    };
-    bold: {
-        red: (text: string) => string;
-        green: (text: string) => string;
-        yellow: (text: string) => string;
-        blue: (text: string) => string;
-        purple: (text: string) => string;
-        cyan: (text: string) => string;
-    };
-    inverse: {
-        red: (text: string) => string;
-        green: (text: string) => string;
-        yellow: (text: string) => string;
-        blue: (text: string) => string;
-        purple: (text: string) => string;
-        cyan: (text: string) => string;
-    };
-    underline: {
-        red: (text: string) => string;
-        green: (text: string) => string;
-        yellow: (text: string) => string;
-        blue: (text: string) => string;
-        purple: (text: string) => string;
-        cyan: (text: string) => string;
-    };
-};
-export type Ansi = typeof ansi;