@marianmeres/stuic 1.125.0 → 2.0.0-next.2

package/dist/utils/calculate-alignment.d.ts

@@ -1,68 +0,0 @@
-export interface AreaLike {
-    width: number;
-    height: number;
-}
-export interface PositionLike {
-    x: number;
-    y: number;
-}
-export interface RectLike extends AreaLike, PositionLike {
-}
-export type Alignment = 'top' | 'topRight' | 'topLeft' | 'right' | 'rightTop' | 'rightBottom' | 'bottom' | 'bottomRight' | 'bottomLeft' | 'left' | 'leftTop' | 'leftBottom';
-export declare const calculateAlignment: (boundaryRoot: RectLike, anchor: RectLike, el: AreaLike, offset?: number) => {
-    origin: {
-        top: {
-            x: number;
-            y: number;
-        };
-        topRight: {
-            x: number;
-            y: number;
-        };
-        topLeft: {
-            x: number;
-            y: number;
-        };
-        bottom: {
-            x: number;
-            y: number;
-        };
-        bottomRight: {
-            x: number;
-            y: number;
-        };
-        bottomLeft: {
-            x: number;
-            y: number;
-        };
-        left: {
-            x: number;
-            y: number;
-        };
-        leftTop: {
-            x: number;
-            y: number;
-        };
-        leftBottom: {
-            x: number;
-            y: number;
-        };
-        right: {
-            x: number;
-            y: number;
-        };
-        rightTop: {
-            x: number;
-            y: number;
-        };
-        rightBottom: {
-            x: number;
-            y: number;
-        };
-    };
-    position: Record<Alignment, PositionLike & {
-        safeY: boolean;
-        safeX: boolean;
-        safe: boolean;
-    }>;
-};

package/dist/utils/calculate-alignment.js

@@ -1,183 +0,0 @@
-const clog = console.log;
-// just basic plus/minus stuff
-export const calculateAlignment = (boundaryRoot, 
-// anchor box
-anchor, 
-//  element to be placed (the one we're calculating position for)
-el, 
-// in px
-offset = 5) => {
-    const anchorHalfWidth = anchor.width / 2;
-    const anchorHalfHeight = anchor.height / 2;
-    // x/y of the origin (center of the anchor with applied offset) position
-    const originTop = { x: anchor.x + anchorHalfWidth, y: anchor.y - offset };
-    const originBottom = {
-        x: anchor.x + anchorHalfWidth,
-        y: anchor.y + anchor.height + offset,
-    };
-    const originLeft = { x: anchor.x - offset, y: anchor.y + anchorHalfHeight };
-    const originRight = {
-        x: anchor.x + anchor.width + offset,
-        y: anchor.y + anchorHalfHeight,
-    };
-    const origin = {
-        top: originTop,
-        topRight: originTop,
-        topLeft: originTop,
-        //
-        bottom: originBottom,
-        bottomRight: originBottom,
-        bottomLeft: originBottom,
-        //
-        left: originLeft,
-        leftTop: originLeft,
-        leftBottom: originLeft,
-        //
-        right: originRight,
-        rightTop: originRight,
-        rightBottom: originRight,
-    };
-    const elHalfWidth = el.width / 2;
-    const elHalfHeigh = el.height / 2;
-    // position is named from the "anchor alignment" relative perspective
-    const position = {
-        //
-        top: {
-            x: origin.top.x - elHalfWidth,
-            y: origin.top.y - el.height,
-            safeX: true,
-            safeY: true,
-            safe: true,
-        },
-        topRight: {
-            x: origin.top.x + anchorHalfWidth - el.width,
-            y: origin.top.y - el.height,
-            safeX: true,
-            safeY: true,
-            safe: true,
-        },
-        topLeft: {
-            x: origin.top.x - anchorHalfWidth,
-            y: origin.top.y - el.height,
-            safeX: true,
-            safeY: true,
-            safe: true,
-        },
-        right: {
-            x: origin.right.x,
-            y: origin.right.y - elHalfHeigh,
-            safeX: true,
-            safeY: true,
-            safe: true,
-        },
-        rightTop: {
-            x: origin.right.x,
-            y: origin.right.y - anchorHalfHeight,
-            safeX: true,
-            safeY: true,
-            safe: true,
-        },
-        rightBottom: {
-            x: origin.right.x,
-            y: origin.right.y + anchorHalfHeight - el.height,
-            safeX: true,
-            safeY: true,
-            safe: true,
-        },
-        //
-        bottom: {
-            x: origin.bottom.x - elHalfWidth,
-            y: origin.bottom.y,
-            safeX: true,
-            safeY: true,
-            safe: true,
-        },
-        bottomLeft: {
-            x: origin.bottom.x - anchorHalfWidth,
-            y: origin.bottom.y,
-            safeX: true,
-            safeY: true,
-            safe: true,
-        },
-        bottomRight: {
-            x: origin.bottom.x + anchorHalfWidth - el.width,
-            y: origin.bottom.y,
-            safeX: true,
-            safeY: true,
-            safe: true,
-        },
-        //
-        left: {
-            x: origin.left.x - el.width,
-            y: origin.left.y - elHalfHeigh,
-            safeX: true,
-            safeY: true,
-            safe: true,
-        },
-        leftTop: {
-            x: origin.left.x - el.width,
-            y: origin.left.y - anchorHalfHeight,
-            safeX: true,
-            safeY: true,
-            safe: true,
-        },
-        leftBottom: {
-            x: origin.left.x - el.width,
-            y: origin.left.y + anchorHalfHeight - el.height,
-            safeX: true,
-            safeY: true,
-            safe: true,
-        },
-    };
-    const isSafeX = (x) => x >= boundaryRoot.x && x + el.width <= boundaryRoot.x + boundaryRoot.width;
-    const isSafeY = (y) => y >= boundaryRoot.y && y + el.height <= boundaryRoot.y + boundaryRoot.height;
-    //
-    Object.entries(position).forEach((entry) => {
-        const [plc, { x, y }] = entry;
-        position[plc].safeX = isSafeX(x);
-        position[plc].safeY = isSafeY(y);
-        position[plc].safe = position[plc].safeX && position[plc].safeY;
-    });
-    // now, the positions were calculated, but so far, we're too strict, so there will
-    // be unnecessary false negatives, which can be relaxed using "fluid" approach
-    // must come below safety check above
-    const fluid = {
-        x: {
-            top: Math.max(0, position.top.x),
-            topLeft: position.topLeft.x - (position.topLeft.x + el.width - boundaryRoot.width),
-            topRight: Math.max(0, position.topRight.x),
-            //
-            bottom: Math.max(0, position.bottom.x),
-            bottomLeft: position.bottomLeft.x - (position.bottomLeft.x + el.width - boundaryRoot.width),
-            bottomRight: Math.max(0, position.bottomRight.x),
-        },
-        y: {
-            // right: position.top.y - (position.top.y + el.height - boundaryRoot.height),
-            right: Math.max(0, position.right.y),
-            rightTop: Math.max(0, position.rightTop.y),
-            rightBottom: Math.max(0, position.rightBottom.y),
-        },
-    };
-    // x axis
-    if (el.width < boundaryRoot.width && anchor.x > 0) {
-        ['top', 'topLeft', 'topRight', 'bottom', 'bottomLeft', 'bottomRight'].forEach((k) => {
-            if (!position[k].safeX && fluid.x?.[k] !== undefined) {
-                position[k].x = fluid.x[k];
-                position[k].safeX = isSafeX(position[k].x);
-                position[k].safe = position[k].safeX && position[k].safeY;
-            }
-        });
-    }
-    // y
-    if (el.height < boundaryRoot.height && anchor.y > 0) {
-        ['right', 'rightTop', 'rightBottom', 'left', 'leftTop', 'leftBottom'].forEach((k) => {
-            if (!position[k].safeY && fluid.y?.[k] !== undefined) {
-                position[k].y = fluid.y[k];
-                position[k].safeY = isSafeY(position[k].y);
-                position[k].safe = position[k].safeX && position[k].safeY;
-            }
-        });
-    }
-    // todo y fluids
-    return { origin, position };
-};

package/dist/utils/device-pointer.d.ts

@@ -1,5 +0,0 @@
-export declare class DevicePointer {
-    static readonly isNone: boolean | undefined;
-    static readonly isCoarse: boolean | undefined;
-    static readonly isFine: boolean | undefined;
-}

package/dist/utils/device-pointer.js

@@ -1,10 +0,0 @@
-const _window = typeof window !== 'undefined' ? window : null;
-export class DevicePointer {
-    // none - The primary input mechanism does not include a pointing device.
-    static isNone = _window?.matchMedia('(any-pointer:none)').matches;
-    // coarse - The primary input mechanism includes a pointing device of limited accuracy,
-    // such as a finger on a touchscreen.
-    static isCoarse = _window?.matchMedia('(any-pointer:coarse)').matches;
-    // fine - The primary input mechanism includes an accurate pointing device, such as a mouse.
-    static isFine = _window?.matchMedia('(any-pointer:fine)').matches;
-}

package/dist/utils/prefers-reduced-motion.d.ts

@@ -1,6 +0,0 @@
-/**
- * Indicates that the user has enabled reduced motion on their device.
- *
- * @see https://developer.mozilla.org/en-US/docs/Web/CSS/@media/prefers-reduced-motion
- */
-export declare const prefersReducedMotionStore: import("svelte/store").Readable<boolean>;

package/dist/utils/prefers-reduced-motion.js

@@ -1,26 +0,0 @@
-import { readable } from 'svelte/store';
-import { BROWSER } from 'esm-env';
-/** Prefers reduced motion  */
-const reducedMotionQuery = '(prefers-reduced-motion: reduce)';
-function prefersReducedMotion() {
-    if (!BROWSER)
-        return false;
-    return window.matchMedia(reducedMotionQuery).matches;
-}
-/**
- * Indicates that the user has enabled reduced motion on their device.
- *
- * @see https://developer.mozilla.org/en-US/docs/Web/CSS/@media/prefers-reduced-motion
- */
-export const prefersReducedMotionStore = readable(prefersReducedMotion(), (set) => {
-    if (BROWSER) {
-        const setReducedMotion = (event) => {
-            set(event.matches);
-        };
-        const mediaQueryList = window.matchMedia(reducedMotionQuery);
-        mediaQueryList.addEventListener('change', setReducedMotion);
-        return () => {
-            mediaQueryList.removeEventListener('change', setReducedMotion);
-        };
-    }
-});

package/dist/utils/tw-merge2.d.ts

@@ -1,3 +0,0 @@
-import { type ClassNameValue } from 'tailwind-merge';
-export declare const clsClean: (s: ClassNameValue) => string;
-export declare const twMerge2: (...args: ClassNameValue[]) => string;

package/dist/utils/tw-merge2.js

@@ -1,9 +0,0 @@
-import { twMerge } from 'tailwind-merge';
-export const clsClean = (s) => {
-    if (Array.isArray(s))
-        s = s.join(' ');
-    return `${s || ''}`.replace(/\s+/g, ' ').trim();
-};
-// twMerge does not seem to handle "\r", "\n" and/or "\t" within the input strings correctly,
-// so we need to do the cleanup ourselves
-export const twMerge2 = (...args) => twMerge(...args.map(clsClean));

package/dist/utils/tw-types.d.ts

@@ -1 +0,0 @@
-export type TW_COLORS = 'slate' | 'gray' | 'zinc' | 'neutral' | 'stone' | 'red' | 'orange' | 'amber' | 'yellow' | 'lime' | 'green' | 'emerald' | 'teal' | 'cyan' | 'sky' | 'blue' | 'indigo' | 'violet' | 'purple' | 'fuchsia' | 'pink' | 'rose';

package/dist/utils/window-size.d.ts

@@ -1,22 +0,0 @@
-export declare const windowSize: {
-    touch: () => void;
-    subscribe(this: void, run: import("svelte/store").Subscriber<{
-        width: number;
-        height: number;
-        scale: number;
-    }>, invalidate?: import("svelte/store").Invalidator<{
-        width: number;
-        height: number;
-        scale: number;
-    }> | undefined): import("svelte/store").Unsubscriber;
-};
-interface Breakpoint {
-    __current__: null | string;
-    sm: boolean;
-    md: boolean;
-    lg: boolean;
-    xl: boolean;
-    '2xl': boolean;
-}
-export declare const breakpoint: import("svelte/store").Readable<Breakpoint>;
-export {};

package/dist/utils/window-size.js

@@ -1,35 +0,0 @@
-import { derived, writable } from 'svelte/store';
-const _window = typeof window !== 'undefined' ? window : null;
-const getWindowSize = () => {
-    const { width, height, scale } = _window?.visualViewport || {
-        width: 0,
-        height: 0,
-        scale: 1,
-    };
-    return { width, height, scale };
-};
-let _trigger = writable(0);
-export const windowSize = {
-    ...derived([_trigger], ([_]) => getWindowSize()),
-    touch: () => _trigger.set(Date.now()),
-};
-// init now!
-windowSize.touch();
-// intentionally not debounced
-_window?.visualViewport?.addEventListener('resize', windowSize.touch);
-_window?.visualViewport?.addEventListener('scroll', windowSize.touch);
-export const breakpoint = derived([windowSize], ([{ width: w }]) => {
-    const list = [
-        ['sm', 640],
-        ['md', 768],
-        ['lg', 1024],
-        ['xl', 1280],
-        ['2xl', 1536],
-    ];
-    // return list.reduce<string | null>((m, [k, v]) => (w && w >= v ? k : m), null);
-    return list.reduce((m, [k, v]) => {
-        const flag = w && w >= v;
-        m = { ...m, [k]: flag, __current__: flag ? k : m.__current__ };
-        return m;
-    }, { __current__: null, sm: false, md: false, lg: false, xl: false, '2xl': false });
-});