lapikit 0.0.0-insiders.0003d39

package/dist/components/tooltip/tooltip.svelte.js

@@ -0,0 +1,131 @@
+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/components/tooltip/types.d.ts

@@ -0,0 +1,23 @@
+import type { Component } from '../../internal/types.js';
+import type { Snippet } from 'svelte';
+export interface TooltipProps extends Component {
+    open?: boolean;
+    dark?: boolean;
+    light?: boolean;
+    rounded?: string;
+    label?: string;
+    location?: 'top' | 'bottom' | 'left' | 'right';
+    color?: string;
+    background?: string;
+    delayDuration?: number;
+    variant?: 'arrow';
+    density?: 'compact' | 'comfortable' | 'default';
+    disabled?: boolean;
+    avoidCollisions?: boolean;
+    tooltip?: Snippet;
+}
+export type PositionElement = {
+    x: number;
+    y: number;
+    location: string | null;
+};

package/dist/components/tooltip/types.js

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

package/dist/index.d.ts

@@ -0,0 +1 @@
+export declare function helloWorld(): void;

package/dist/index.js

@@ -0,0 +1,4 @@
+// Reexport your entry components here
+export function helloWorld() {
+    console.log('Hello world, this is lapikit!');
+}

package/dist/internal/ansi.d.ts

@@ -0,0 +1,40 @@
+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;

package/dist/internal/ansi.js

@@ -0,0 +1,44 @@
+const color = {
+    red: (text) => `\x1b[31m${text}\x1b[0m`,
+    green: (text) => `\x1b[32m${text}\x1b[0m`,
+    yellow: (text) => `\x1b[33m${text}\x1b[0m`,
+    blue: (text) => `\x1b[34m${text}\x1b[0m`,
+    purple: (text) => `\x1b[35m${text}\x1b[0m`,
+    cyan: (text) => `\x1b[36m${text}\x1b[0m`
+};
+const variant = {
+    bold: (text) => `\x1b[1m${text}\x1b[0m`,
+    underline: (text) => `\x1b[4m${text}\x1b[0m`,
+    inverse: (text) => `\x1b[7m${text}\x1b[0m`
+};
+const bold = {
+    red: (text) => `\x1b[1m\x1b[31m${text}\x1b[0m`,
+    green: (text) => `\x1b[1m\x1b[32m${text}\x1b[0m`,
+    yellow: (text) => `\x1b[1m\x1b[33m${text}\x1b[0m`,
+    blue: (text) => `\x1b[1m\x1b[34m${text}\x1b[0m`,
+    purple: (text) => `\x1b[1m\x1b[35m${text}\x1b[0m`,
+    cyan: (text) => `\x1b[1m\x1b[36m${text}\x1b[0m`
+};
+const inverse = {
+    red: (text) => `\x1b[7m\x1b[31m${text}\x1b[0m`,
+    green: (text) => `\x1b[7m\x1b[32m${text}\x1b[0m`,
+    yellow: (text) => `\x1b[7m\x1b[33m${text}\x1b[0m`,
+    blue: (text) => `\x1b[7m\x1b[34m${text}\x1b[0m`,
+    purple: (text) => `\x1b[7m\x1b[35m${text}\x1b[0m`,
+    cyan: (text) => `\x1b[7m\x1b[36m${text}\x1b[0m`
+};
+const underline = {
+    red: (text) => `\x1b[4m\x1b[31m${text}\x1b[0m`,
+    green: (text) => `\x1b[4m\x1b[32m${text}\x1b[0m`,
+    yellow: (text) => `\x1b[4m\x1b[33m${text}\x1b[0m`,
+    blue: (text) => `\x1b[4m\x1b[34m${text}\x1b[0m`,
+    purple: (text) => `\x1b[4m\x1b[35m${text}\x1b[0m`,
+    cyan: (text) => `\x1b[4m\x1b[36m${text}\x1b[0m`
+};
+export const ansi = {
+    color,
+    variant,
+    bold,
+    inverse,
+    underline
+};

package/dist/internal/assets.svelte.d.ts

@@ -0,0 +1,8 @@
+export declare function getAssets(): {
+    shape(params?: string): string | undefined;
+    className(key: string, type: string, value: string | boolean | Array<string> | {
+        [key: string]: string;
+    }): string | undefined;
+    color(color?: string): string | undefined;
+    unit(value?: string | number): string | undefined;
+};

package/dist/internal/assets.svelte.js

@@ -0,0 +1,54 @@
+import { x11ColorNames } from '../utils/x11.js';
+export function getAssets() {
+    return {
+        shape(params) {
+            if (params) {
+                if (params === 'none' || params == '0')
+                    return '0';
+                return `var(--kit-radius-${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 === '_default' ? '' : `${media}:`}kit--${type}`)
+                        .join(' ');
+                }
+                else {
+                    return Object.entries(value)
+                        .map(([media, value]) => `${media === '_default' ? '' : `${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/internal/clickOutside.d.ts

@@ -0,0 +1,9 @@
+type ClickOutsideOptions = {
+    exclude?: (HTMLElement | PointerEvent | null)[];
+    onClose: () => void;
+};
+export declare function clickOutside(node: HTMLElement, options: ClickOutsideOptions): {
+    update(newOptions: ClickOutsideOptions): void;
+    destroy(): void;
+};
+export {};

package/dist/internal/clickOutside.js

@@ -0,0 +1,34 @@
+export function clickOutside(node, options) {
+    let { exclude = [], onClose } = options;
+    function isTargetExcluded(target) {
+        return exclude.some((ex) => {
+            if (!ex)
+                return false;
+            if (ex instanceof HTMLElement) {
+                return ex.contains(target);
+            }
+            if (ex instanceof PointerEvent && ex.target instanceof Node) {
+                return ex.target.contains(target);
+            }
+            return false;
+        });
+    }
+    const handleClick = (event) => {
+        const target = event.target;
+        const isExcluded = isTargetExcluded(target);
+        const isInside = node.contains(target);
+        if (!isInside && !isExcluded) {
+            onClose();
+        }
+    };
+    document.addEventListener('click', handleClick, true);
+    return {
+        update(newOptions) {
+            exclude = newOptions.exclude || [];
+            onClose = newOptions.onClose;
+        },
+        destroy() {
+            document.removeEventListener('click', handleClick, true);
+        }
+    };
+}

package/dist/internal/colors.d.ts

@@ -0,0 +1 @@
+export declare const parseColor: (input: string) => string;

package/dist/internal/colors.js

@@ -0,0 +1,50 @@
+import { x11Colors } from '../utils/x11.js';
+export const parseColor = (input) => {
+    input = input.trim();
+    if (input.startsWith('#')) {
+        const rgb = hexToRgb(input);
+        return rgbToOklch(rgb.r, rgb.g, rgb.b);
+    }
+    if (input.startsWith('rgb')) {
+        const parts = input
+            .replace(/rgba?|\(|\)|\s+/g, '')
+            .split(',')
+            .map(Number);
+        return rgbToOklch(parts[0], parts[1], parts[2]);
+    }
+    if (input.startsWith('oklch('))
+        return input;
+    if (x11Colors[input]) {
+        const hex = x11Colors[input];
+        const rgb = hexToRgb(hex);
+        return rgbToOklch(rgb.r, rgb.g, rgb.b);
+    }
+    return input;
+};
+const hexToRgb = (hex) => {
+    const clean = hex.replace('#', '');
+    const bigint = parseInt(clean, 16);
+    return {
+        r: (bigint >> 16) & 255,
+        g: (bigint >> 8) & 255,
+        b: bigint & 255
+    };
+};
+const srgbToLinear = (c) => (c <= 0.04045 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4);
+const rgbToOklch = (r, g, b) => {
+    r = srgbToLinear(r / 255);
+    g = srgbToLinear(g / 255);
+    b = srgbToLinear(b / 255);
+    const l = 0.4122214708 * r + 0.5363325363 * g + 0.0514459929 * b;
+    const m = 0.2119034982 * r + 0.6806995451 * g + 0.1073969566 * b;
+    const s = 0.0883024619 * r + 0.2817188376 * g + 0.6299787005 * b;
+    const l_ = Math.cbrt(l);
+    const m_ = Math.cbrt(m);
+    const s_ = Math.cbrt(s);
+    const L = 0.2104542553 * l_ + 0.793617785 * m_ - 0.0040720468 * s_;
+    const a = 1.9779984951 * l_ - 2.428592205 * m_ + 0.4505937099 * s_;
+    const b_ = 0.0259040371 * l_ + 0.7827717662 * m_ - 0.808675766 * s_;
+    const C = Math.sqrt(a * a + b_ * b_);
+    const h = (Math.atan2(b_, a) * 180) / Math.PI;
+    return `oklch(${(L * 100).toFixed(3)}% ${C.toFixed(4)} ${((h + 360) % 360).toFixed(2)})`;
+};

package/dist/internal/index.d.ts

@@ -0,0 +1,4 @@
+export * from './terminal.js';
+export * from './ansi.js';
+export * from './assets.svelte.js';
+export * from './scroll.js';

package/dist/internal/index.js

@@ -0,0 +1,4 @@
+export * from './terminal.js';
+export * from './ansi.js';
+export * from './assets.svelte.js';
+export * from './scroll.js';

package/dist/internal/minify.d.ts

@@ -0,0 +1 @@
+export declare const minify: (css: string) => string;

package/dist/internal/minify.js

@@ -0,0 +1,10 @@
+export const minify = (css) => {
+    const minified = css
+        .replace(/\s+/g, ' ')
+        .replace(/\/\*.*?\*\//g, '')
+        .replace(/;\s*}/g, '}')
+        .replace(/:\s+/g, ':')
+        .replace(/\s*([{};:])\s*/g, '$1')
+        .trim();
+    return minified;
+};

package/dist/internal/ripple.d.ts

@@ -0,0 +1,12 @@
+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/internal/ripple.js

@@ -0,0 +1,93 @@
+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 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 || el.hasAttribute('aria-disabled')) {
+            rippleContainer.remove();
+        }
+        else {
+            el.appendChild(rippleContainer);
+        }
+        if (options.duration && options.duration < 0) {
+            options.duration = undefined;
+        }
+        if (options.component) {
+            rippleContainer.style.setProperty('--ripple-radius', `var(--${options.component}-radius)`);
+        }
+        if (options.color) {
+            rippleContainer.style.setProperty('--ripple-color', options.color);
+        }
+        if (options.duration) {
+            rippleContainer.style.setProperty('--ripple-duration', `${options.duration}ms`);
+        }
+    }
+    function createRipple(e, center) {
+        if (options.disabled || el.hasAttribute('aria-disabled')) {
+            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/internal/scroll.d.ts

@@ -0,0 +1 @@
+export declare function disabledScroll(state: boolean): void;

package/dist/internal/scroll.js

@@ -0,0 +1,6 @@
+import { BROWSER } from 'esm-env';
+export function disabledScroll(state) {
+    if (BROWSER) {
+        document.body.style.overflow = state ? 'hidden' : '';
+    }
+}

package/dist/internal/terminal.d.ts

@@ -0,0 +1 @@
+export declare const terminal: (type: "info" | "error" | "warn" | "success" | undefined, msg: string) => void;

package/dist/internal/terminal.js

@@ -0,0 +1,12 @@
+import { ansi } from './ansi.js';
+export const terminal = (type = 'info', msg) => {
+    const name = ansi.color.cyan('lapikit');
+    if (type === 'error')
+        console.error(name, ansi.bold.red('[error]'), msg);
+    else if (type === 'warn')
+        console.warn(name, ansi.bold.yellow('[warn]'), msg);
+    else if (type === 'success')
+        console.warn(name, ansi.bold.green('[success]'), msg);
+    else
+        console.log(name, ansi.bold.blue('[info]'), msg);
+};

package/dist/internal/types.d.ts

@@ -0,0 +1,57 @@
+import type { Snippet } from 'svelte';
+type IdElementType = string | undefined;
+type ClassNameType = string | string[] | undefined;
+type StylePropertiesType = string | undefined;
+export interface Base {
+    id?: IdElementType;
+    class?: ClassNameType;
+    style?: StylePropertiesType;
+    [key: string]: any;
+}
+export interface Component extends Base {
+    children?: Snippet;
+}
+export type FontFamily = {
+    [key: string]: string | string[];
+};
+export type Colors = {
+    [key: string]: {
+        light: string;
+        dark: string;
+    } | string;
+};
+export type Thresholds = {
+    [key: string]: number | string;
+};
+export type Radius = {
+    [key: string]: number | string;
+};
+export interface Lapikit {
+    options: {
+        normalize: boolean;
+        minify: boolean;
+    };
+    theme: {
+        colorScheme: string;
+        colors: Colors;
+    };
+    breakpoints: {
+        mobileBreakpoint: string;
+        tabletBreakpoint: string;
+        laptopBreakpoint: string;
+        thresholds: Thresholds;
+    };
+    styles: {
+        spacing: string;
+        corner: {
+            active: boolean;
+            radius: Radius;
+        };
+        font: FontFamily;
+    };
+}
+type DeepOptional<T> = {
+    [P in keyof T]?: T[P] extends (infer U)[] ? DeepOptional<U>[] : T[P] extends object ? DeepOptional<T[P]> : T[P];
+};
+export type LapikitConfig = DeepOptional<Lapikit>;
+export {};

package/dist/internal/types.js

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

package/dist/internal/unit.d.ts

@@ -0,0 +1 @@
+export declare const setUnit: (value: string | number) => string;

package/dist/internal/unit.js

@@ -0,0 +1,11 @@
+export const setUnit = (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/plugin/modules/config.d.ts

@@ -0,0 +1,2 @@
+import type { LapikitConfig } from '../../internal/types.js';
+export declare const parseConfig: (props?: LapikitConfig) => import("../../internal/types.js").Lapikit;