@moving-walls/design-system 2.0.1 → 2.0.2

package/dist/node_modules/@floating-ui/core/dist/floating-ui.core.d.mts

@@ -0,0 +1,215 @@
+export { rectToClientRect } from "@floating-ui/utils";
+/**
+ * Provides data to position an inner element of the floating element so that it
+ * appears centered to the reference element.
+ * @see https://floating-ui.com/docs/arrow
+ */
+export function arrow(options: any): {
+    name: string;
+    options: any;
+    fn(state: any): Promise<{
+        data?: undefined;
+        reset?: undefined;
+    } | {
+        [x: string]: any;
+        data: {
+            alignmentOffset?: number | undefined;
+            centerOffset: number;
+        };
+        reset: boolean;
+    }>;
+};
+/**
+ * Optimizes the visibility of the floating element by choosing the placement
+ * that has the most space available automatically, without needing to specify a
+ * preferred placement. Alternative to `flip`.
+ * @see https://floating-ui.com/docs/autoPlacement
+ */
+export function autoPlacement(options: any): {
+    name: string;
+    options: any;
+    fn(state: any): Promise<{
+        reset?: undefined;
+        data?: undefined;
+    } | {
+        reset: {
+            placement: any;
+        };
+        data?: undefined;
+    } | {
+        data: {
+            index: any;
+            overflows: any[];
+        };
+        reset: {
+            placement: any;
+        };
+    }>;
+};
+/**
+ * Computes the `x` and `y` coordinates that will place the floating element
+ * next to a given reference element.
+ *
+ * This export does not have any `platform` interface logic. You will need to
+ * write one for the platform you are using Floating UI with.
+ */
+export function computePosition(reference: any, floating: any, config: any): Promise<{
+    x: any;
+    y: any;
+    placement: any;
+    strategy: any;
+    middlewareData: {};
+}>;
+/**
+ * Resolves with an object of overflow side offsets that determine how much the
+ * element is overflowing a given clipping boundary on each side.
+ * - positive = overflowing the boundary by that number of pixels
+ * - negative = how many pixels left before it will overflow
+ * - 0 = lies flush with the boundary
+ * @see https://floating-ui.com/docs/detectOverflow
+ */
+export function detectOverflow(state: any, options: any): Promise<{
+    top: number;
+    bottom: number;
+    left: number;
+    right: number;
+}>;
+/**
+ * Optimizes the visibility of the floating element by flipping the `placement`
+ * in order to keep it in view when the preferred placement(s) will overflow the
+ * clipping boundary. Alternative to `autoPlacement`.
+ * @see https://floating-ui.com/docs/flip
+ */
+export function flip(options: any): {
+    name: string;
+    options: any;
+    fn(state: any): Promise<{
+        data?: undefined;
+        reset?: undefined;
+    } | {
+        data: {
+            index: any;
+            overflows: any;
+        };
+        reset: {
+            placement: any;
+        };
+    } | {
+        reset: {
+            placement: any;
+        };
+        data?: undefined;
+    }>;
+};
+/**
+ * Provides data to hide the floating element in applicable situations, such as
+ * when it is not in the same clipping context as the reference element.
+ * @see https://floating-ui.com/docs/hide
+ */
+export function hide(options: any): {
+    name: string;
+    options: any;
+    fn(state: any): Promise<{
+        data: {
+            referenceHiddenOffsets: {
+                top: number;
+                right: number;
+                bottom: number;
+                left: number;
+            };
+            referenceHidden: boolean;
+            escapedOffsets?: undefined;
+            escaped?: undefined;
+        };
+    } | {
+        data: {
+            escapedOffsets: {
+                top: number;
+                right: number;
+                bottom: number;
+                left: number;
+            };
+            escaped: boolean;
+            referenceHiddenOffsets?: undefined;
+            referenceHidden?: undefined;
+        };
+    } | {
+        data?: undefined;
+    }>;
+};
+/**
+ * Provides improved positioning for inline reference elements that can span
+ * over multiple lines, such as hyperlinks or range selections.
+ * @see https://floating-ui.com/docs/inline
+ */
+export function inline(options: any): {
+    name: string;
+    options: any;
+    fn(state: any): Promise<{
+        reset: {
+            rects: any;
+        };
+    } | {
+        reset?: undefined;
+    }>;
+};
+/**
+ * Built-in `limiter` that will stop `shift()` at a certain point.
+ */
+export function limitShift(options: any): {
+    options: any;
+    fn(state: any): {
+        [x: string]: any;
+    };
+};
+/**
+ * Modifies the placement by translating the floating element along the
+ * specified axes.
+ * A number (shorthand for `mainAxis` or distance), or an axes configuration
+ * object may be passed.
+ * @see https://floating-ui.com/docs/offset
+ */
+export function offset(options: any): {
+    name: string;
+    options: any;
+    fn(state: any): Promise<{
+        x?: undefined;
+        y?: undefined;
+        data?: undefined;
+    } | {
+        x: any;
+        y: any;
+        data: {
+            placement: any;
+            x: number;
+            y: number;
+        };
+    }>;
+};
+/**
+ * Optimizes the visibility of the floating element by shifting it in order to
+ * keep it in view when it will overflow the clipping boundary.
+ * @see https://floating-ui.com/docs/shift
+ */
+export function shift(options: any): {
+    name: string;
+    options: any;
+    fn(state: any): Promise<any>;
+};
+/**
+ * Provides data that allows you to change the size of the floating element —
+ * for instance, prevent it from overflowing the clipping boundary or match the
+ * width of the reference element.
+ * @see https://floating-ui.com/docs/size
+ */
+export function size(options: any): {
+    name: string;
+    options: any;
+    fn(state: any): Promise<{
+        reset: {
+            rects: boolean;
+        };
+    } | {
+        reset?: undefined;
+    }>;
+};

package/dist/node_modules/@floating-ui/dom/dist/floating-ui.dom.d.mts

@@ -0,0 +1,131 @@
+export { getOverflowAncestors } from "@floating-ui/utils/dom";
+/**
+ * Provides data to position an inner element of the floating element so that it
+ * appears centered to the reference element.
+ * @see https://floating-ui.com/docs/arrow
+ */
+export const arrow: (options: import("@floating-ui/core").ArrowOptions | import("@floating-ui/core").Derivable<import("@floating-ui/core").ArrowOptions>) => import("@floating-ui/core").Middleware;
+/**
+ * Optimizes the visibility of the floating element by choosing the placement
+ * that has the most space available automatically, without needing to specify a
+ * preferred placement. Alternative to `flip`.
+ * @see https://floating-ui.com/docs/autoPlacement
+ */
+export const autoPlacement: (options?: import("@floating-ui/core").AutoPlacementOptions | import("@floating-ui/core").Derivable<import("@floating-ui/core").AutoPlacementOptions>) => import("@floating-ui/core").Middleware;
+/**
+ * Automatically updates the position of the floating element when necessary.
+ * Should only be called when the floating element is mounted on the DOM or
+ * visible on the screen.
+ * @returns cleanup function that should be invoked when the floating element is
+ * removed from the DOM or hidden from the screen.
+ * @see https://floating-ui.com/docs/autoUpdate
+ */
+export function autoUpdate(reference: any, floating: any, update: any, options: any): () => void;
+/**
+ * Computes the `x` and `y` coordinates that will place the floating element
+ * next to a given reference element.
+ */
+export function computePosition(reference: any, floating: any, options: any): Promise<import("@floating-ui/core").ComputePositionReturn>;
+/**
+ * Resolves with an object of overflow side offsets that determine how much the
+ * element is overflowing a given clipping boundary on each side.
+ * - positive = overflowing the boundary by that number of pixels
+ * - negative = how many pixels left before it will overflow
+ * - 0 = lies flush with the boundary
+ * @see https://floating-ui.com/docs/detectOverflow
+ */
+export const detectOverflow: typeof detectOverflow$1;
+/**
+ * Optimizes the visibility of the floating element by flipping the `placement`
+ * in order to keep it in view when the preferred placement(s) will overflow the
+ * clipping boundary. Alternative to `autoPlacement`.
+ * @see https://floating-ui.com/docs/flip
+ */
+export const flip: (options?: import("@floating-ui/core").FlipOptions | import("@floating-ui/core").Derivable<import("@floating-ui/core").FlipOptions>) => import("@floating-ui/core").Middleware;
+/**
+ * Provides data to hide the floating element in applicable situations, such as
+ * when it is not in the same clipping context as the reference element.
+ * @see https://floating-ui.com/docs/hide
+ */
+export const hide: (options?: import("@floating-ui/core").HideOptions | import("@floating-ui/core").Derivable<import("@floating-ui/core").HideOptions>) => import("@floating-ui/core").Middleware;
+/**
+ * Provides improved positioning for inline reference elements that can span
+ * over multiple lines, such as hyperlinks or range selections.
+ * @see https://floating-ui.com/docs/inline
+ */
+export const inline: (options?: import("@floating-ui/core").InlineOptions | import("@floating-ui/core").Derivable<import("@floating-ui/core").InlineOptions>) => import("@floating-ui/core").Middleware;
+/**
+ * Built-in `limiter` that will stop `shift()` at a certain point.
+ */
+export const limitShift: (options?: import("@floating-ui/core").LimitShiftOptions | import("@floating-ui/core").Derivable<import("@floating-ui/core").LimitShiftOptions>) => {
+    options: any;
+    fn: (state: import("@floating-ui/core").MiddlewareState) => import("@floating-ui/utils").Coords;
+};
+/**
+ * Modifies the placement by translating the floating element along the
+ * specified axes.
+ * A number (shorthand for `mainAxis` or distance), or an axes configuration
+ * object may be passed.
+ * @see https://floating-ui.com/docs/offset
+ */
+export const offset: (options?: import("@floating-ui/core").OffsetOptions) => import("@floating-ui/core").Middleware;
+export namespace platform {
+    export { convertOffsetParentRelativeRectToViewportRelativeRect };
+    export { getDocumentElement };
+    export { getClippingRect };
+    export { getOffsetParent };
+    export { getElementRects };
+    export { getClientRects };
+    export { getDimensions };
+    export { getScale };
+    export { isElement };
+    export { isRTL };
+}
+/**
+ * Optimizes the visibility of the floating element by shifting it in order to
+ * keep it in view when it will overflow the clipping boundary.
+ * @see https://floating-ui.com/docs/shift
+ */
+export const shift: (options?: import("@floating-ui/core").ShiftOptions | import("@floating-ui/core").Derivable<import("@floating-ui/core").ShiftOptions>) => import("@floating-ui/core").Middleware;
+/**
+ * Provides data that allows you to change the size of the floating element —
+ * for instance, prevent it from overflowing the clipping boundary or match the
+ * width of the reference element.
+ * @see https://floating-ui.com/docs/size
+ */
+export const size: (options?: import("@floating-ui/core").SizeOptions | import("@floating-ui/core").Derivable<import("@floating-ui/core").SizeOptions>) => import("@floating-ui/core").Middleware;
+import { detectOverflow as detectOverflow$1 } from '@floating-ui/core';
+declare function convertOffsetParentRelativeRectToViewportRelativeRect(_ref: any): any;
+import { getDocumentElement } from '@floating-ui/utils/dom';
+declare function getClippingRect(_ref: any): {
+    width: number;
+    height: number;
+    x: any;
+    y: any;
+};
+declare function getOffsetParent(element: any, polyfill: any): any;
+declare function getElementRects(data: any): Promise<{
+    reference: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    floating: {
+        x: number;
+        y: number;
+        width: any;
+        height: any;
+    };
+}>;
+declare function getClientRects(element: any): any[];
+declare function getDimensions(element: any): {
+    width: number;
+    height: number;
+};
+declare function getScale(element: any): {
+    x: number;
+    y: number;
+};
+import { isElement } from '@floating-ui/utils/dom';
+declare function isRTL(element: any): boolean;

package/dist/node_modules/@floating-ui/react-dom/dist/floating-ui.react-dom.d.mts

@@ -0,0 +1,129 @@
+/**
+ * Provides data to position an inner element of the floating element so that it
+ * appears centered to the reference element.
+ * This wraps the core `arrow` middleware to allow React refs as the element.
+ * @see https://floating-ui.com/docs/arrow
+ */
+export function arrow(options: any, deps: any): {
+    options: any[];
+    name: string;
+    fn(state: any): import("@floating-ui/core").MiddlewareReturn | Promise<import("@floating-ui/core").MiddlewareReturn>;
+};
+/**
+ * Optimizes the visibility of the floating element by choosing the placement
+ * that has the most space available automatically, without needing to specify a
+ * preferred placement. Alternative to `flip`.
+ * @see https://floating-ui.com/docs/autoPlacement
+ */
+export function autoPlacement(options: any, deps: any): {
+    options: any[];
+    name: string;
+    fn: (state: import("@floating-ui/dom").MiddlewareState) => import("@floating-ui/core").MiddlewareReturn | Promise<import("@floating-ui/core").MiddlewareReturn>;
+};
+/**
+ * Optimizes the visibility of the floating element by flipping the `placement`
+ * in order to keep it in view when the preferred placement(s) will overflow the
+ * clipping boundary. Alternative to `autoPlacement`.
+ * @see https://floating-ui.com/docs/flip
+ */
+export function flip(options: any, deps: any): {
+    options: any[];
+    name: string;
+    fn: (state: import("@floating-ui/dom").MiddlewareState) => import("@floating-ui/core").MiddlewareReturn | Promise<import("@floating-ui/core").MiddlewareReturn>;
+};
+/**
+ * Provides data to hide the floating element in applicable situations, such as
+ * when it is not in the same clipping context as the reference element.
+ * @see https://floating-ui.com/docs/hide
+ */
+export function hide(options: any, deps: any): {
+    options: any[];
+    name: string;
+    fn: (state: import("@floating-ui/dom").MiddlewareState) => import("@floating-ui/core").MiddlewareReturn | Promise<import("@floating-ui/core").MiddlewareReturn>;
+};
+/**
+ * Provides improved positioning for inline reference elements that can span
+ * over multiple lines, such as hyperlinks or range selections.
+ * @see https://floating-ui.com/docs/inline
+ */
+export function inline(options: any, deps: any): {
+    options: any[];
+    name: string;
+    fn: (state: import("@floating-ui/dom").MiddlewareState) => import("@floating-ui/core").MiddlewareReturn | Promise<import("@floating-ui/core").MiddlewareReturn>;
+};
+/**
+ * Built-in `limiter` that will stop `shift()` at a certain point.
+ */
+export function limitShift(options: any, deps: any): {
+    options: any[];
+    fn: (state: import("@floating-ui/dom").MiddlewareState) => import("@floating-ui/utils").Coords;
+};
+/**
+ * Modifies the placement by translating the floating element along the
+ * specified axes.
+ * A number (shorthand for `mainAxis` or distance), or an axes configuration
+ * object may be passed.
+ * @see https://floating-ui.com/docs/offset
+ */
+export function offset(options: any, deps: any): {
+    options: any[];
+    name: string;
+    fn: (state: import("@floating-ui/dom").MiddlewareState) => import("@floating-ui/core").MiddlewareReturn | Promise<import("@floating-ui/core").MiddlewareReturn>;
+};
+/**
+ * Optimizes the visibility of the floating element by shifting it in order to
+ * keep it in view when it will overflow the clipping boundary.
+ * @see https://floating-ui.com/docs/shift
+ */
+export function shift(options: any, deps: any): {
+    options: any[];
+    name: string;
+    fn: (state: import("@floating-ui/dom").MiddlewareState) => import("@floating-ui/core").MiddlewareReturn | Promise<import("@floating-ui/core").MiddlewareReturn>;
+};
+/**
+ * Provides data that allows you to change the size of the floating element —
+ * for instance, prevent it from overflowing the clipping boundary or match the
+ * width of the reference element.
+ * @see https://floating-ui.com/docs/size
+ */
+export function size(options: any, deps: any): {
+    options: any[];
+    name: string;
+    fn: (state: import("@floating-ui/dom").MiddlewareState) => import("@floating-ui/core").MiddlewareReturn | Promise<import("@floating-ui/core").MiddlewareReturn>;
+};
+/**
+ * Provides data to position a floating element.
+ * @see https://floating-ui.com/docs/useFloating
+ */
+export function useFloating(options: any): {
+    update: () => void;
+    refs: {
+        reference: React.MutableRefObject<null>;
+        floating: React.MutableRefObject<null>;
+        setReference: (node: any) => void;
+        setFloating: (node: any) => void;
+    };
+    elements: {
+        reference: any;
+        floating: any;
+    };
+    floatingStyles: {
+        position: any;
+        left: number;
+        top: number;
+    } | {
+        willChange?: string | undefined;
+        transform: string;
+        position: any;
+        left: number;
+        top: number;
+    };
+    x: number;
+    y: number;
+    strategy: any;
+    placement: any;
+    middlewareData: {};
+    isPositioned: boolean;
+};
+import * as React from 'react';
+export { autoUpdate, computePosition, detectOverflow, getOverflowAncestors, platform } from "@floating-ui/dom";

package/dist/node_modules/@floating-ui/utils/dist/floating-ui.utils.d.mts

@@ -0,0 +1,40 @@
+export const alignments: string[];
+export function clamp(start: any, value: any, end: any): number;
+export function createCoords(v: any): {
+    x: any;
+    y: any;
+};
+export function evaluate(value: any, param: any): any;
+export function expandPaddingObject(padding: any): any;
+export const floor: (x: number) => number;
+export function getAlignment(placement: any): any;
+export function getAlignmentAxis(placement: any): "x" | "y";
+export function getAlignmentSides(placement: any, rects: any, rtl: any): any[];
+export function getAxisLength(axis: any): "width" | "height";
+export function getExpandedPlacements(placement: any): any[];
+export function getOppositeAlignmentPlacement(placement: any): any;
+export function getOppositeAxis(axis: any): "x" | "y";
+export function getOppositeAxisPlacements(placement: any, flipAlignment: any, direction: any, rtl: any): string[];
+export function getOppositePlacement(placement: any): any;
+export function getPaddingObject(padding: any): any;
+export function getSide(placement: any): any;
+export function getSideAxis(placement: any): "x" | "y";
+export const max: (...values: number[]) => number;
+export const min: (...values: number[]) => number;
+export const placements: any[];
+export function rectToClientRect(rect: any): {
+    width: any;
+    height: any;
+    top: any;
+    left: any;
+    right: any;
+    bottom: any;
+    x: any;
+    y: any;
+};
+export const round: (x: number) => number;
+/**
+ * Custom positioning reference element.
+ * @see https://floating-ui.com/docs/virtual-elements
+ */
+export const sides: string[];

package/dist/node_modules/@floating-ui/utils/dist/floating-ui.utils.dom.d.mts

@@ -0,0 +1,23 @@
+export function getComputedStyle(element: any): any;
+export function getContainingBlock(element: any): any;
+export function getDocumentElement(node: any): any;
+export function getFrameElement(win: any): any;
+export function getNearestOverflowAncestor(node: any): any;
+export function getNodeName(node: any): any;
+export function getNodeScroll(element: any): {
+    scrollLeft: any;
+    scrollTop: any;
+};
+export function getOverflowAncestors(node: any, list: any, traverseIframes: any): any;
+export function getParentNode(node: any): any;
+export function getWindow(node: any): any;
+export function isContainingBlock(elementOrCss: any): boolean;
+export function isElement(value: any): boolean;
+export function isHTMLElement(value: any): boolean;
+export function isLastTraversableNode(node: any): boolean;
+export function isNode(value: any): boolean;
+export function isOverflowElement(element: any): boolean;
+export function isShadowRoot(value: any): boolean;
+export function isTableElement(element: any): boolean;
+export function isTopLayer(element: any): boolean;
+export function isWebKit(): boolean;

package/dist/node_modules/@radix-ui/number/dist/index.d.mts

@@ -0,0 +1 @@
+export function clamp(value: any, [min, max]: [any, any]): number;

package/dist/node_modules/@radix-ui/primitive/dist/index.d.mts

@@ -0,0 +1,8 @@
+export var canUseDOM: boolean;
+export function composeEventHandlers(originalEventHandler: any, ourEventHandler: any, { checkForDefaultPrevented }?: {
+    checkForDefaultPrevented?: boolean | undefined;
+}): (event: any) => any;
+export function getActiveElement(node: any, activeDescendant?: boolean): any;
+export function getOwnerDocument(element: any): any;
+export function getOwnerWindow(element: any): any;
+export function isFrame(element: any): boolean;

package/dist/node_modules/@radix-ui/react-arrow/dist/index.d.mts

@@ -0,0 +1,3 @@
+export var Arrow: React.ForwardRefExoticComponent<React.RefAttributes<any>>;
+export var Root: React.ForwardRefExoticComponent<React.RefAttributes<any>>;
+import * as React from "react";