prismify-ui 0.1.0-alpha.1

package/dist/components/overlay/PfDrawer/index.vue.d.ts

@@ -0,0 +1,106 @@
+export type PfDrawerDirection = 'top' | 'bottom' | 'left' | 'right';
+export interface PfDrawerUi {
+    overlay?: string;
+    content?: string;
+    handle?: string;
+    container?: string;
+    header?: string;
+    title?: string;
+    description?: string;
+    body?: string;
+    footer?: string;
+}
+type __VLS_Props = {
+    title?: string;
+    description?: string;
+    inset?: boolean;
+    overlay?: boolean;
+    handle?: boolean;
+    handleOnly?: boolean;
+    portal?: string | boolean | HTMLElement | undefined;
+    nested?: boolean;
+    ui?: PfDrawerUi;
+    modal?: boolean;
+    open?: boolean;
+    defaultOpen?: boolean;
+    dismissible?: boolean;
+    transition?: boolean;
+    direction?: PfDrawerDirection;
+    closeThreshold?: number;
+    snapPoints?: (string | number)[];
+    activeSnapPoint?: string | number | null;
+    shouldScaleBackground?: boolean;
+    setBackgroundColorOnScale?: boolean;
+    noBodyStyles?: boolean;
+};
+declare function close(): void;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+        default?(_: {}): any;
+        content?(_: {
+            close: typeof close;
+        }): any;
+        header?(_: {
+            close: typeof close;
+        }): any;
+        title?(_: {}): any;
+        description?(_: {}): any;
+        body?(_: {}): any;
+        footer?(_: {
+            close: typeof close;
+        }): any;
+    };
+    refs: {
+        triggerRef: HTMLDivElement;
+        panelRef: HTMLDivElement;
+        handleRef: HTMLDivElement;
+        containerRef: HTMLDivElement;
+    };
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    close: () => any;
+    "update:open": (value: boolean) => any;
+    drag: (percentageDragged: number) => any;
+    "close:prevent": () => any;
+    "update:activeSnapPoint": (value: string | number) => any;
+    release: (open: boolean) => any;
+    animationEnd: (open: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClose?: (() => any) | undefined;
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+    onDrag?: ((percentageDragged: number) => any) | undefined;
+    "onClose:prevent"?: (() => any) | undefined;
+    "onUpdate:activeSnapPoint"?: ((value: string | number) => any) | undefined;
+    onRelease?: ((open: boolean) => any) | undefined;
+    onAnimationEnd?: ((open: boolean) => any) | undefined;
+}>, {
+    transition: boolean;
+    defaultOpen: boolean;
+    nested: boolean;
+    portal: string | boolean | HTMLElement;
+    modal: boolean;
+    overlay: boolean;
+    dismissible: boolean;
+    handle: boolean;
+    handleOnly: boolean;
+    direction: PfDrawerDirection;
+    closeThreshold: number;
+    setBackgroundColorOnScale: boolean;
+    noBodyStyles: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    triggerRef: HTMLDivElement;
+    panelRef: HTMLDivElement;
+    handleRef: HTMLDivElement;
+    containerRef: HTMLDivElement;
+}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/overlay/PfDropdownMenu/PfDropdownMenuItems.vue.d.ts

@@ -0,0 +1,10 @@
+declare function __VLS_template(): any;
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: any;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/overlay/PfDropdownMenu/index.vue.d.ts

@@ -0,0 +1,74 @@
+import { PfIconName } from '../../element/PfIcon/paths';
+import { PfDropdownMenuContent, PfDropdownMenuFilter, PfDropdownMenuItemsInput, PfDropdownMenuSize, PfDropdownMenuUi } from './types';
+type __VLS_Props = {
+    items?: PfDropdownMenuItemsInput;
+    size?: PfDropdownMenuSize;
+    disabled?: boolean;
+    modal?: boolean;
+    portal?: string | boolean | HTMLElement | undefined;
+    open?: boolean;
+    defaultOpen?: boolean;
+    checkedIcon?: PfIconName;
+    externalIcon?: PfIconName;
+    pressOpenDelay?: number;
+    content?: PfDropdownMenuContent;
+    arrow?: boolean;
+    filter?: PfDropdownMenuFilter;
+    filterFields?: string[];
+    ignoreFilter?: boolean;
+    searchTerm?: string;
+    ui?: PfDropdownMenuUi;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+        item?(_: any): any;
+        'item-leading'?(_: any): any;
+        'item-label'?(_: any): any;
+        'item-description'?(_: any): any;
+        'item-trailing'?(_: any): any;
+        empty?(_: {}): any;
+        'content-top'?(_: {}): any;
+        'content-bottom'?(_: {}): any;
+    };
+    refs: {
+        triggerRef: HTMLDivElement;
+        itemsRef: unknown;
+    };
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:open": (value: boolean) => any;
+    "update:searchTerm": (value: string) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+    "onUpdate:searchTerm"?: ((value: string) => any) | undefined;
+}>, {
+    filter: PfDropdownMenuFilter;
+    size: PfDropdownMenuSize;
+    disabled: boolean;
+    content: PfDropdownMenuContent;
+    defaultOpen: boolean;
+    items: PfDropdownMenuItemsInput;
+    checkedIcon: PfIconName;
+    filterFields: string[];
+    ignoreFilter: boolean;
+    searchTerm: string;
+    portal: string | boolean | HTMLElement;
+    modal: boolean;
+    externalIcon: PfIconName;
+    arrow: boolean;
+    pressOpenDelay: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    triggerRef: HTMLDivElement;
+    itemsRef: unknown;
+}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/overlay/PfDropdownMenu/types.d.ts

@@ -0,0 +1,58 @@
+import { RouteLocationRaw } from 'vue-router';
+import { PfIconName } from '../../element/PfIcon/paths';
+import { PfSelectColor, PfSelectOptionAvatarConfig } from '../../form/PfSelect/index.vue';
+export type PfDropdownMenuSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+export type PfDropdownMenuItemType = 'label' | 'separator' | 'checkbox' | 'link';
+export interface PfDropdownMenuContent {
+    side?: 'top' | 'right' | 'bottom' | 'left';
+    align?: 'start' | 'center' | 'end';
+    sideOffset?: number;
+    alignOffset?: number;
+}
+export interface PfDropdownMenuItem {
+    label?: string;
+    description?: string;
+    icon?: PfIconName;
+    avatar?: PfSelectOptionAvatarConfig;
+    kbds?: string[];
+    type?: PfDropdownMenuItemType;
+    color?: PfSelectColor;
+    checked?: boolean;
+    disabled?: boolean;
+    slot?: string;
+    onSelect?: (e: Event) => void;
+    onUpdateChecked?: (checked: boolean) => void;
+    children?: PfDropdownMenuItem[] | PfDropdownMenuItem[][];
+    filter?: boolean | Record<string, unknown>;
+    filterFields?: string[];
+    ignoreFilter?: boolean;
+    to?: RouteLocationRaw;
+    target?: string;
+    external?: boolean;
+    class?: string;
+    [key: string]: unknown;
+}
+export type PfDropdownMenuItemsInput = readonly PfDropdownMenuItem[] | readonly (readonly PfDropdownMenuItem[])[];
+export type PfDropdownMenuFilter = boolean | Record<string, unknown>;
+export interface PfDropdownMenuUi {
+    content?: string;
+    input?: string;
+    empty?: string;
+    viewport?: string;
+    arrow?: string;
+    group?: string;
+    label?: string;
+    separator?: string;
+    item?: string;
+    itemLeadingIcon?: string;
+    itemLeadingAvatar?: string;
+    itemLeadingAvatarSize?: string;
+    itemTrailing?: string;
+    itemTrailingIcon?: string;
+    itemTrailingKbds?: string;
+    itemTrailingKbdsSize?: string;
+    itemWrapper?: string;
+    itemLabel?: string;
+    itemDescription?: string;
+    itemLabelExternalIcon?: string;
+}

package/dist/components/overlay/PfModal/index.vue.d.ts

@@ -0,0 +1,138 @@
+import { PfIconName } from '../../element/PfIcon/paths';
+export type PfModalCloseButtonProps = Partial<{
+    label: string;
+    color: 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'error' | 'neutral';
+    variant: 'solid' | 'outline' | 'soft' | 'subtle' | 'ghost' | 'link';
+    size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    square: boolean;
+    block: boolean;
+    icon: PfIconName;
+    leading: boolean;
+    leadingIcon: PfIconName;
+    trailing: boolean;
+    trailingIcon: PfIconName;
+    iconOnly: boolean;
+    ariaLabel: string;
+    disabled: boolean;
+    loading: boolean;
+    loadingIcon: PfIconName;
+    loadingAuto: boolean;
+    type: 'button' | 'submit' | 'reset';
+    active: boolean;
+    activeColor: 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'error' | 'neutral';
+    activeVariant: 'solid' | 'outline' | 'soft' | 'subtle' | 'ghost' | 'link';
+}>;
+export interface PfModalUi {
+    overlay?: string;
+    content?: string;
+    header?: string;
+    wrapper?: string;
+    body?: string;
+    footer?: string;
+    title?: string;
+    description?: string;
+    actions?: string;
+    close?: string;
+}
+type __VLS_Props = {
+    title?: string;
+    description?: string;
+    overlay?: boolean;
+    scrollable?: boolean;
+    transition?: boolean;
+    fullscreen?: boolean;
+    portal?: string | boolean | HTMLElement | undefined;
+    close?: boolean | PfModalCloseButtonProps;
+    closeIcon?: PfIconName;
+    dismissible?: boolean;
+    ui?: PfModalUi;
+    open?: boolean;
+    defaultOpen?: boolean;
+    modal?: boolean;
+};
+declare function closeModal(): void;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+        default?(_: {}): any;
+        content?(_: {
+            close: typeof closeModal;
+        }): any;
+        header?(_: {
+            close: typeof closeModal;
+        }): any;
+        title?(_: {}): any;
+        description?(_: {}): any;
+        actions?(_: {
+            close: typeof closeModal;
+        }): any;
+        close?(_: {
+            close: typeof closeModal;
+        }): any;
+        body?(_: {}): any;
+        footer?(_: {
+            close: typeof closeModal;
+        }): any;
+    };
+    refs: {
+        triggerRef: HTMLDivElement;
+        contentRef: HTMLDivElement;
+    };
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:open": (value: boolean) => any;
+    "after:leave": () => any;
+    "after:enter": () => any;
+    "close:prevent": () => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+    "onAfter:leave"?: (() => any) | undefined;
+    "onAfter:enter"?: (() => any) | undefined;
+    "onClose:prevent"?: (() => any) | undefined;
+}>, {
+    close: boolean | Partial<{
+        label: string;
+        color: "primary" | "secondary" | "success" | "info" | "warning" | "error" | "neutral";
+        variant: "solid" | "outline" | "soft" | "subtle" | "ghost" | "link";
+        size: "xs" | "sm" | "md" | "lg" | "xl";
+        square: boolean;
+        block: boolean;
+        icon: PfIconName;
+        leading: boolean;
+        leadingIcon: PfIconName;
+        trailing: boolean;
+        trailingIcon: PfIconName;
+        iconOnly: boolean;
+        ariaLabel: string;
+        disabled: boolean;
+        loading: boolean;
+        loadingIcon: PfIconName;
+        loadingAuto: boolean;
+        type: "button" | "submit" | "reset";
+        active: boolean;
+        activeColor: "primary" | "secondary" | "success" | "info" | "warning" | "error" | "neutral";
+        activeVariant: "solid" | "outline" | "soft" | "subtle" | "ghost" | "link";
+    }>;
+    closeIcon: PfIconName;
+    transition: boolean;
+    defaultOpen: boolean;
+    portal: string | boolean | HTMLElement;
+    modal: boolean;
+    overlay: boolean;
+    scrollable: boolean;
+    fullscreen: boolean;
+    dismissible: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    triggerRef: HTMLDivElement;
+    contentRef: HTMLDivElement;
+}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/overlay/PfToast/index.vue.d.ts

@@ -0,0 +1,128 @@
+import { PfIconName } from '../../element/PfIcon/paths';
+import { PfToastAction, PfToastCloseButton, PfToastColor, PfToastOrientation } from '../../../composables/usePfToast';
+export type PfToastUi = Partial<{
+    root: string;
+    wrapper: string;
+    title: string;
+    description: string;
+    icon: string;
+    actions: string;
+    close: string;
+}>;
+type __VLS_Props = {
+    id?: string;
+    title?: string;
+    description?: string;
+    icon?: PfIconName;
+    color?: PfToastColor;
+    orientation?: PfToastOrientation;
+    close?: boolean | PfToastCloseButton;
+    closeIcon?: PfIconName;
+    actions?: PfToastAction[];
+    progress?: boolean;
+    progressDuration?: number;
+    progressPaused?: boolean;
+    ui?: PfToastUi;
+    pulse?: number;
+};
+declare function onCloseClick(): void;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        leading?(_: {}): any;
+        title?(_: {}): any;
+        description?(_: {}): any;
+        actions?(_: {}): any;
+        actions?(_: {}): any;
+        close?(_: {
+            close: typeof onCloseClick;
+        }): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    close: () => any;
+    action: (action: Partial<{
+        label: string;
+        color: PfToastColor;
+        variant: "solid" | "outline" | "soft" | "subtle" | "ghost" | "link";
+        size: "xs" | "sm" | "md" | "lg" | "xl";
+        icon: PfIconName;
+        leading: boolean;
+        trailing: boolean;
+        ariaLabel: string;
+        disabled: boolean;
+        loading: boolean;
+        type: "button" | "submit" | "reset";
+        href: string;
+        to: string;
+        target: string;
+        rel: string;
+        download: boolean | string;
+        onClick: (event?: MouseEvent) => void;
+    }>, event: MouseEvent) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClose?: (() => any) | undefined;
+    onAction?: ((action: Partial<{
+        label: string;
+        color: PfToastColor;
+        variant: "solid" | "outline" | "soft" | "subtle" | "ghost" | "link";
+        size: "xs" | "sm" | "md" | "lg" | "xl";
+        icon: PfIconName;
+        leading: boolean;
+        trailing: boolean;
+        ariaLabel: string;
+        disabled: boolean;
+        loading: boolean;
+        type: "button" | "submit" | "reset";
+        href: string;
+        to: string;
+        target: string;
+        rel: string;
+        download: boolean | string;
+        onClick: (event?: MouseEvent) => void;
+    }>, event: MouseEvent) => any) | undefined;
+}>, {
+    pulse: number;
+    progress: boolean;
+    color: PfToastColor;
+    orientation: PfToastOrientation;
+    actions: Partial<{
+        label: string;
+        color: PfToastColor;
+        variant: "solid" | "outline" | "soft" | "subtle" | "ghost" | "link";
+        size: "xs" | "sm" | "md" | "lg" | "xl";
+        icon: PfIconName;
+        leading: boolean;
+        trailing: boolean;
+        ariaLabel: string;
+        disabled: boolean;
+        loading: boolean;
+        type: "button" | "submit" | "reset";
+        href: string;
+        to: string;
+        target: string;
+        rel: string;
+        download: boolean | string;
+        onClick: (event?: MouseEvent) => void;
+    }>[];
+    close: boolean | Partial<{
+        color: PfToastColor;
+        variant: "solid" | "outline" | "soft" | "subtle" | "ghost" | "link";
+        size: "xs" | "sm" | "md" | "lg" | "xl";
+        class: string;
+        ariaLabel: string;
+    }>;
+    closeIcon: PfIconName;
+    progressDuration: number;
+    progressPaused: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/overlay/PfToaster/index.vue.d.ts

@@ -0,0 +1,11 @@
+type __VLS_Props = {
+    position?: 'top-left' | 'top-center' | 'top-right' | 'bottom-left' | 'bottom-center' | 'bottom-right';
+    duration?: number;
+    max?: number;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    max: number;
+    position: "top-left" | "top-center" | "top-right" | "bottom-left" | "bottom-center" | "bottom-right";
+    duration: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/overlay/PfTooltip/index.vue.d.ts

@@ -0,0 +1,85 @@
+import { PfKbdColor, PfKbdSize, PfKbdUi, PfKbdVariant } from '../../element/PfKbd/index.vue';
+export type PfTooltipSide = 'top' | 'right' | 'bottom' | 'left';
+export type PfTooltipAlign = 'start' | 'center' | 'end';
+export interface PfTooltipReferenceElement {
+    getBoundingClientRect: () => DOMRect;
+}
+export interface PfTooltipContentProps {
+    side?: PfTooltipSide;
+    align?: PfTooltipAlign;
+    sideOffset?: number;
+    alignOffset?: number;
+    updatePositionStrategy?: 'optimized' | 'always';
+}
+export interface PfTooltipArrowProps {
+    width?: number;
+    height?: number;
+}
+export interface PfTooltipKbdProps {
+    value?: string;
+    color?: PfKbdColor;
+    variant?: PfKbdVariant;
+    size?: PfKbdSize;
+    ui?: PfKbdUi;
+    class?: string;
+}
+export type PfTooltipKbd = string | undefined | PfTooltipKbdProps;
+export interface PfTooltipUi {
+    content?: string;
+    arrow?: string;
+    text?: string;
+    kbds?: string;
+    kbdsSize?: PfKbdSize;
+}
+type __VLS_Props = {
+    text?: string;
+    kbds?: PfTooltipKbd[];
+    content?: PfTooltipContentProps;
+    arrow?: boolean | PfTooltipArrowProps;
+    portal?: string | boolean | HTMLElement;
+    reference?: PfTooltipReferenceElement;
+    ui?: PfTooltipUi;
+    defaultOpen?: boolean;
+    open?: boolean;
+    delayDuration?: number;
+    disableHoverableContent?: boolean;
+    disableClosingTrigger?: boolean;
+    disabled?: boolean;
+    ignoreNonKeyboardFocus?: boolean;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+        content?(_: {}): any;
+    };
+    refs: {
+        triggerRef: HTMLSpanElement;
+        contentRef: HTMLDivElement;
+    };
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:open": (value: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+}>, {
+    disabled: boolean;
+    content: PfTooltipContentProps;
+    defaultOpen: boolean;
+    kbds: PfTooltipKbd[];
+    portal: string | boolean | HTMLElement;
+    arrow: boolean | PfTooltipArrowProps;
+    ignoreNonKeyboardFocus: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    triggerRef: HTMLSpanElement;
+    contentRef: HTMLDivElement;
+}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/composables/pfScrollAreaVirtual.d.ts

@@ -0,0 +1,21 @@
+/** Internal layout helpers for PfScrollArea (no external virtualizer dependency). */
+export type PfMasonryItemLayout = {
+    top: number;
+    left: number;
+    width: number;
+    height: number;
+};
+export declare function buildLinearOffsets(sizes: readonly number[], gap: number, paddingStart: number, _axis: 'vertical' | 'horizontal'): number[];
+export declare function linearTotalSize(offsets: readonly number[], sizes: readonly number[], paddingEnd: number): number;
+export declare function findVisibleRangeLinear(offsets: readonly number[], sizes: readonly number[], scrollStart: number, viewport: number, overscanPx: number): {
+    start: number;
+    end: number;
+};
+export declare function computeMasonryLayouts(heights: readonly number[], lanes: number, containerInnerWidth: number, gap: number, paddingStart: number): {
+    layouts: PfMasonryItemLayout[];
+    totalHeight: number;
+};
+export declare function findMasonryVisibleRange(layouts: readonly PfMasonryItemLayout[], scrollTop: number, viewport: number, overscanPx: number): {
+    start: number;
+    end: number;
+};

package/dist/composables/usePfApp.d.ts

@@ -0,0 +1,7 @@
+import { ComputedRef } from 'vue';
+import { PfAppContextValue } from '../components/layout/PfApp/injection';
+/**
+ * Global app context from the nearest `PfApp`.
+ * Outside `PfApp`, defaults are used (`portalTarget: 'body'`).
+ */
+export declare function usePfApp(): ComputedRef<PfAppContextValue>;

package/dist/composables/usePfContentSearch.d.ts

@@ -0,0 +1,11 @@
+import { ComputedRef, Ref } from 'vue';
+export interface PfContentSearchState {
+    isOpen: Ref<boolean>;
+    searchTerm: Ref<string>;
+    open: () => void;
+    close: () => void;
+    toggle: () => void;
+    setSearchTerm: (value: string) => void;
+    hasSearchTerm: ComputedRef<boolean>;
+}
+export declare function usePfContentSearch(): PfContentSearchState;

package/dist/composables/usePfKbd.d.ts

@@ -0,0 +1,14 @@
+import { ComputedRef } from 'vue';
+/**
+ * Glyphs for special keys (similar to Nuxt UI `kbdKeysMap`).
+ * Keys are lowercased for lookup.
+ */
+export declare const PF_KBD_GLYPHS: Readonly<Record<string, string>>;
+/**
+ * Display text: literal or special key name (`meta` → ⌘ on macOS, `Ctrl` otherwise).
+ */
+export declare function getPfKbdKey(value: string): string;
+export declare function usePfKbd(): {
+    macOS: ComputedRef<boolean>;
+    getKbdKey: typeof getPfKbdKey;
+};