v-float 0.9.1 → 0.11.0

package/dist/composables/positioning/use-arrow.d.ts

@@ -1,55 +0,0 @@
-import { ComputedRef, Ref } from 'vue';
-import { FloatingContext } from './use-floating';
-/**
- * Return value of the useArrow composable
- */
-export interface UseArrowReturn {
-    /**
-     * The computed X position of the arrow
-     */
-    arrowX: ComputedRef<number>;
-    /**
-     * The computed Y position of the arrow
-     */
-    arrowY: ComputedRef<number>;
-    /**
-     * The computed CSS styles for positioning the arrow
-     */
-    arrowStyles: ComputedRef<Record<string, string>>;
-}
-/**
- * Options for the useArrow composable
- */
-export interface UseArrowOptions {
-    /**
-     * Controls the offset of the arrow from the edge of the floating element.
-     *
-     * A positive value moves the arrow further into the floating element,
-     * while a negative value creates a gap between the arrow and the element.
-     * This is useful for preventing the arrow from overlapping borders or shadows.
-     *
-     * The value must be a valid CSS length (e.g., '5px', '-0.5rem').
-     *
-     * @default '-4px'
-     */
-    offset?: string;
-}
-/**
- * Composable for computing arrow position styles for floating elements
- *
- * This composable calculates the position and styles for an arrow element
- * based on the placement and middleware data from a floating element.
- *
- * @param arrowEl - A ref to the arrow HTML element
- * @param context - The floating context containing middleware data and placement information
- * @param options - Optional configuration for the arrow, e.g., offset
- * @returns Computed arrow positions and CSS styles
- *
- * @example
- * ```ts
- * const arrowRef = ref<HTMLElement | null>(null)
- * const { arrowStyles } = useArrow(arrowRef, floatingContext, { offset: "-10px" })
- * ```
- */
-export declare function useArrow(arrowEl: Ref<HTMLElement | null>, context: FloatingContext, options?: UseArrowOptions): UseArrowReturn;
-//# sourceMappingURL=use-arrow.d.ts.map

package/dist/composables/positioning/use-arrow.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"use-arrow.d.ts","sourceRoot":"","sources":["../../../src/composables/positioning/use-arrow.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,GAAG,EAAE,MAAM,KAAK,CAAA;AAE3C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAA;AAMrD;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B;;OAEG;IACH,MAAM,EAAE,WAAW,CAAC,MAAM,CAAC,CAAA;IAE3B;;OAEG;IACH,MAAM,EAAE,WAAW,CAAC,MAAM,CAAC,CAAA;IAE3B;;OAEG;IACH,WAAW,EAAE,WAAW,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;CACjD;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B;;;;;;;;;;OAUG;IACH,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB;AAMD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,QAAQ,CACtB,OAAO,EAAE,GAAG,CAAC,WAAW,GAAG,IAAI,CAAC,EAChC,OAAO,EAAE,eAAe,EACxB,OAAO,GAAE,eAAoB,GAC5B,cAAc,CAyDhB"}

package/dist/composables/positioning/use-client-point.d.ts

@@ -1,218 +0,0 @@
-import { MaybeRefOrGetter, Ref } from 'vue';
-import { VirtualElement } from '../../types';
-import { AnchorElement } from './use-floating';
-/**
- * Represents 2D coordinates with optional null values for unset states
- */
-export interface Coordinates {
-    x: number | null;
-    y: number | null;
-}
-/**
- * Axis constraint types for coordinate positioning
- */
-export type AxisConstraint = "x" | "y" | "both";
-/**
- * Tracking mode for client point positioning behavior
- */
-export type TrackingMode = "follow" | "static";
-/**
- * Processed pointer event data
- */
-interface PointerEventData {
-    type: "pointerdown" | "pointermove" | "pointerenter";
-    coordinates: Coordinates;
-    originalEvent: PointerEvent;
-}
-/**
- * Context for tracking strategy operations
- */
-interface TrackingContext {
-    isOpen: boolean;
-}
-export interface UseClientPointOptions {
-    /**
-     * Whether the Hook is enabled
-     * @default true
-     */
-    enabled?: MaybeRefOrGetter<boolean>;
-    /**
-     * Whether to restrict the client point to an axis
-     * @default 'both'
-     */
-    axis?: MaybeRefOrGetter<AxisConstraint>;
-    /**
-     * Controlled x coordinate
-     * @default null
-     */
-    x?: MaybeRefOrGetter<number | null>;
-    /**
-     * Controlled y coordinate
-     * @default null
-     */
-    y?: MaybeRefOrGetter<number | null>;
-    /**
-     * Tracking behavior mode:
-     * - "follow": Continuous cursor tracking (default)
-     * - "static": Position at initial interaction, no subsequent tracking
-     * @default "follow"
-     */
-    trackingMode?: TrackingMode;
-}
-export interface UseClientPointReturn {
-    /**
-     * Reactive object containing the current client coordinates (x/y)
-     */
-    coordinates: Readonly<Ref<{
-        x: number | null;
-        y: number | null;
-    }>>;
-    /**
-     * Function to manually update the floating element's position
-     */
-    updatePosition: (x: number, y: number) => void;
-}
-export interface UseClientPointContext {
-    open: Readonly<Ref<boolean>>;
-    refs: {
-        anchorEl: Ref<AnchorElement>;
-    };
-}
-/**
- * Virtual element factory for floating positioning anchors.
- * Creates virtual DOM elements that serve as positioning anchors.
- */
-export declare class VirtualElementFactory {
-    private static readonly DEFAULT_DIMENSIONS;
-    /**
-     * Create a virtual anchor element
-     */
-    create(options: {
-        coordinates: Coordinates;
-        referenceElement?: HTMLElement | null;
-        baselineCoordinates?: Coordinates | null;
-        axis?: AxisConstraint;
-    }): VirtualElement;
-    /**
-     * Build configuration from options with defaults
-     */
-    private buildConfiguration;
-    /**
-     * Build the bounding rectangle for the virtual element
-     */
-    private buildBoundingRect;
-    /**
-     * Get reference element bounds with fallback
-     */
-    private getReferenceRect;
-    /**
-     * Resolve final position from coordinate sources
-     */
-    private resolvePosition;
-    /**
-     * Resolve coordinate for a single axis with clear precedence
-     */
-    private resolveAxisCoordinate;
-    /**
-     * Calculate virtual element size based on axis constraints
-     */
-    private calculateSize;
-    /**
-     * Build a DOMRect object
-     */
-    private buildDOMRect;
-}
-/**
- * Abstract base class for tracking strategies
- */
-export declare abstract class TrackingStrategy {
-    abstract readonly name: TrackingMode;
-    protected lastKnownCoordinates: Coordinates | null;
-    /**
-     * Process a pointer event and return coordinates if the strategy wants to update
-     * This is the heart of each strategy's behavior
-     */
-    abstract process(event: PointerEventData, context: TrackingContext): Coordinates | null;
-    /**
-     * Get the list of pointer events this strategy needs to listen for
-     * This allows strategies to optimize performance by only registering necessary events
-     */
-    abstract getRequiredEvents(): PointerEventData["type"][];
-    /**
-     * Get coordinates to use when the floating element opens
-     * This lets each strategy decide its opening behavior without client code needing to know the details
-     */
-    getCoordinatesForOpening(): Coordinates | null;
-    /**
-     * Called when the floating element closes
-     * This is where strategies should clean up any temporary state
-     */
-    onClose(): void;
-    /**
-     * Reset all strategy state - used when the composable is disabled or reset
-     */
-    reset(): void;
-}
-/**
- * Strategy for continuous cursor tracking
- */
-export declare class FollowTracker extends TrackingStrategy {
-    readonly name: "follow";
-    /**
-     * Follow strategy needs all pointer events for continuous tracking
-     */
-    getRequiredEvents(): PointerEventData["type"][];
-    /**
-     * Follow strategy: always update coordinates based on the current pointer position
-     * This creates smooth, continuous tracking behavior
-     */
-    process(event: PointerEventData, context: TrackingContext): Coordinates | null;
-}
-/**
- * Strategy for static positioning at initial interaction
- */
-export declare class StaticTracker extends TrackingStrategy {
-    readonly name: "static";
-    private triggerCoordinates;
-    /**
-     * Static strategy only needs click events, not hover or continuous movement
-     * This optimization avoids registering unnecessary pointer events
-     */
-    getRequiredEvents(): PointerEventData["type"][];
-    /**
-     * Static strategy: capture coordinates from trigger events, ignore movement
-     * This creates stable positioning that doesn't jump around
-     */
-    process(event: PointerEventData, context: TrackingContext): Coordinates | null;
-    /**
-     * Get coordinates to use when floating element opens
-     */
-    getCoordinatesForOpening(): Coordinates | null;
-    /**
-     * Reset tracking state
-     */
-    reset(): void;
-    onClose(): void;
-}
-/**
- * Positions the floating element relative to a client point (mouse position).
- *
- * This composable tracks pointer movements and positions the floating element
- * accordingly, with options for axis locking and controlled coordinates.
- *
- * @param pointerTarget - The DOM element whose bounding box is used as the reference for pointer event listeners and initial positioning.
- * @param context - The floating context with open state and position reference
- * @param options - Configuration options for client point behavior
- *
- * @example
- * ```ts
- * const context = useFloating(...)
- * useClientPoint(context, {
- *   axis: "x",
- *   enabled: true
- * })
- * ```
- */
-export declare function useClientPoint(pointerTarget: Ref<HTMLElement | null>, context: UseClientPointContext, options?: UseClientPointOptions): UseClientPointReturn;
-export {};
-//# sourceMappingURL=use-client-point.d.ts.map

package/dist/composables/positioning/use-client-point.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"use-client-point.d.ts","sourceRoot":"","sources":["../../../src/composables/positioning/use-client-point.ts"],"names":[],"mappings":"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"}

package/dist/composables/positioning/use-floating-tree.d.ts

@@ -1,240 +0,0 @@
-import { Ref } from 'vue';
-import { AnchorElement, FloatingContext, FloatingElement, UseFloatingOptions } from './use-floating';
-/**
- * Options for creating a TreeNode
- */
-export interface CreateTreeNodeOptions {
-    /** Optional ID for the node. If not provided, one will be generated. */
-    id?: string;
-}
-/**
- * Options for configuring tree behavior
- */
-export interface CreateTreeOptions {
-    /** Strategy for deleting child nodes when a parent is deleted.
-     * - 'orphan': Children are detached from the tree (parent becomes null).
-     * - 'recursive': Children are also deleted recursively.
-     * @default 'recursive'
-     */
-    deleteStrategy?: "orphan" | "recursive";
-}
-interface AddNodeOptions extends UseFloatingOptions {
-    /**
-     * Parent node ID for tree hierarchy.
-     * @default undefined
-     */
-    parentId?: string;
-}
-/**
- * Represents a single node in a tree structure with hierarchical relationships.
- *
- * A TreeNode maintains references to its parent and children, allowing bidirectional
- * traversal of the tree. Each node stores generic data and provides methods for
- * tree navigation and manipulation.
- *
- * @template T The type of data stored in the node
- *
- * @example
- * ```ts
- * const node = createTreeNode({ name: 'Parent' });
- * const childNode = createTreeNode({ name: 'Child' }, node);
- * node.addChild(childNode);
- * ```
- */
-export interface TreeNode<T> {
-    /**
-     * Unique identifier for this node
-     */
-    readonly id: string;
-    /**
-     * The data stored in this node
-     */
-    readonly data: T;
-    /**
-     * Reference to the parent node, or null if this is the root
-     */
-    readonly parent: Ref<TreeNode<T> | null>;
-    /**
-     * Array of child nodes
-     */
-    readonly children: Ref<TreeNode<T>[]>;
-    /**
-     * Whether this node is the root of the tree
-     */
-    readonly isRoot: boolean;
-    /**
-     * Computed property indicating whether this node has no children
-     */
-    readonly isLeaf: Readonly<Ref<boolean>>;
-    /**
-     * Adds a child node to this node's children array
-     */
-    addChild: (childNode: TreeNode<T>) => void;
-    /**
-     * Internal method to remove a child instance from this node
-     */
-    _removeChildInstance: (childNode: TreeNode<T>) => boolean;
-    /**
-     * Finds the first immediate child matching the predicate
-     */
-    findChild: (predicate: (node: TreeNode<T>) => boolean) => TreeNode<T> | null;
-    /**
-     * Recursively finds the first descendant matching the predicate
-     */
-    findDescendant: (predicate: (node: TreeNode<T>) => boolean) => TreeNode<T> | null;
-    /**
-     * Checks if this node is a descendant of the given ancestor
-     */
-    isDescendantOf: (potentialAncestor: TreeNode<T>) => boolean;
-    /**
-     * Returns the path from root to this node (inclusive)
-     */
-    getPath: () => TreeNode<T>[];
-}
-/**
- * Core tree data structure for managing hierarchical node relationships.
- *
- * Provides methods for adding, removing, moving, and traversing nodes.
- * Maintains a root node and a map of all nodes for efficient lookups.
- * Supports both orphaning and recursive deletion strategies.
- *
- * @template T The type of data stored in tree nodes
- *
- * @example
- * ```ts
- * const tree = createTree<{ name: string }>();
- * const child = tree.addNode({ name: 'Child' }, tree.root?.id);
- * tree.traverse('dfs'); // Get all nodes in depth-first order
- * ```
- */
-export interface Tree<T> {
-    /**
-     * The root node of the tree, or null if empty
-     */
-    readonly root: TreeNode<T> | null;
-    /**
-     * Read-only map of all nodes indexed by their ID for O(1) lookups
-     */
-    readonly nodeMap: Readonly<Map<string, TreeNode<T>>>;
-    /**
-     * Finds a node by its ID anywhere in the tree
-     */
-    findNodeById: (id: string) => TreeNode<T> | null;
-    /**
-     * Adds a new node to the tree as a child of the specified parent
-     */
-    addNode: (data: T, parentId?: string | null, nodeOptions?: CreateTreeNodeOptions) => TreeNode<T> | null;
-    /**
-     * Removes a node from the tree using the specified deletion strategy
-     */
-    removeNode: (nodeId: string, deleteStrategy?: "orphan" | "recursive") => boolean;
-    /**
-     * Moves a node to become a child of a different parent
-     */
-    moveNode: (nodeId: string, newParentId: string | null) => boolean;
-    /**
-     * Traverses the tree using DFS or BFS strategy, optionally starting from a specific node
-     */
-    traverse: (strategy?: "dfs" | "bfs", startNode?: TreeNode<T> | null) => TreeNode<T>[];
-    /**
-     * Clears all nodes from the tree to allow garbage collection
-     */
-    dispose: () => void;
-}
-/**
- * Configuration options for the floating tree
- */
-export interface FloatingTreeOptions extends CreateTreeOptions {
-}
-/**
- * Return type for the useFloatingTree composable.
- *
- * Extends the base Tree interface with floating-specific methods for managing
- * a hierarchical tree of floating UI elements. Each node wraps a FloatingContext
- * and provides methods to query and manipulate open states across the tree.
- *
- * @example
- * ```ts
- * const tree = useFloatingTree();
- * const childNode = tree.addNode(anchorEl, floatingEl, { parentId: tree.root?.id });
- * const deepest = tree.getDeepestOpenNode();
- * tree.applyToNodes(childNode.id, (node) => node.data.setOpen(false), {
- *   relationship: 'descendants-only'
- * });
- * ```
- */
-export interface UseFloatingTreeReturn extends Omit<Tree<FloatingContext>, "addNode" | "root"> {
-    /**
-     * The root node of the floating tree
-     */
-    root: TreeNode<FloatingContext> | null;
-    /**
-     * Adds a new floating element node to the tree with the specified anchor and floating elements
-     */
-    addNode: (anchorEl: Ref<AnchorElement>, floatingEl: Ref<FloatingElement>, options?: AddNodeOptions) => TreeNode<FloatingContext> | null;
-    /**
-     * Returns an array of all nodes that are currently open
-     */
-    getAllOpenNodes: () => TreeNode<FloatingContext>[];
-    /**
-     * Returns the deepest (most nested) open node in the tree, or null if none are open
-     */
-    getDeepestOpenNode: () => TreeNode<FloatingContext> | null;
-    /**
-     * Executes a provided function once for each tree node that matches the specified relationship.
-     * This is a flexible iteration method that can target nodes based on their relationship to a target node.
-     *
-     * @param nodeId - The ID of the target node used as a reference point for the relationship
-     * @param callback - A function to execute for each matching node
-     * @param options - Configuration options for the iteration behavior
-     */
-    applyToNodes: (nodeId: string, callback: (node: TreeNode<FloatingContext>) => void, options?: {
-        relationship?: NodeRelationship;
-        applyToMatching?: boolean;
-    }) => void;
-}
-/**
- * Predefined node relationship strategies used for filtering nodes.
- */
-type NodeRelationship = "ancestors-only" | "siblings-only" | "descendants-only" | "children-only" | "self-and-ancestors" | "self-and-children" | "self-and-descendants" | "self-and-siblings" | "self-ancestors-and-children" | "full-branch" | "all-except-branch";
-/**
- * Creates and manages a hierarchical tree of floating elements.
- *
- * Each node in the tree is assigned a stable ID. For non-root nodes, `addNode` generates
- * the ID and injects it into the created FloatingContext (passed to `useFloating`).
- * Consumers should not provide a custom `id` in `UseFloatingOptions` when using `addNode`;
- * it will be ignored in favor of the generated one.
- *
- * @param treeOptions - Options for tree behavior
- * @returns UseFloatingTreeReturn with tree management methods and root context
- */
-export declare function useFloatingTree(treeOptions?: FloatingTreeOptions): UseFloatingTreeReturn;
-/**
- * Creates a reactive tree node with data, parent reference, and children references.
- * @param data The data to store in the node
- * @param parent The parent node, or null for root nodes
- * @param options Configuration options for the node
- * @param isRoot Whether this node is the true root of a tree
- * @returns A reactive tree node object with methods and reactive properties
- */
-export declare function createTreeNode<T>(data: T, parent?: TreeNode<T> | null, options?: CreateTreeNodeOptions, isRoot?: boolean): TreeNode<T>;
-/**
- * Creates and manages a reactive tree structure.
- *
- * This factory function provides a complete tree data structure with reactive nodes,
- * supporting operations like adding, removing, and moving nodes, as well as
- * traversal and search functionality.
- *
- * @template T The type of data stored in the tree nodes.
- * @param options Configuration options for the tree behavior.
- * @returns A tree management object with methods and reactive properties
- *
- * @example
- * ```ts
- * const myTree = createTree<{ name: string }>();
- * const childNode = myTree.addNode({ name: 'Child' }, myTree.root?.id);
- * ```
- */
-export declare function createTree<T>(options?: CreateTreeOptions): Tree<T>;
-export {};
-//# sourceMappingURL=use-floating-tree.d.ts.map

package/dist/composables/positioning/use-floating-tree.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"use-floating-tree.d.ts","sourceRoot":"","sources":["../../../src/composables/positioning/use-floating-tree.ts"],"names":[],"mappings":"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"}