ropav 0.1.6 → 0.1.8

package/dist/components/tags-input/types.d.ts

@@ -0,0 +1,37 @@
+import { InputHTMLAttributes } from 'vue';
+import { StylesApiProps } from '../../styles-api.js';
+export type TagsInputValueValidator = (value: string) => boolean;
+export type TagsInputRadius = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+export type TagsInputSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+export interface TagsInputTagSlotProps {
+    value: string;
+}
+export interface TagsInputProps extends StylesApiProps<TagsInputPart> {
+    id?: string;
+    name?: string;
+    form?: string;
+    modelValue?: string[];
+    defaultValue?: string[];
+    maxTags?: number;
+    allowDuplicates?: boolean;
+    splitChars?: string[];
+    acceptValueOnBlur?: boolean;
+    validate?: TagsInputValueValidator;
+    size?: TagsInputSize;
+    radius?: TagsInputRadius;
+    placeholder?: string;
+    clearable?: boolean;
+    clearLabel?: string;
+    removeLabel?: string;
+    disabled?: boolean;
+    readonly?: boolean;
+    required?: boolean;
+    invalid?: boolean;
+    ariaLabel?: string;
+    describedby?: string;
+    labelledby?: string;
+    inputAttrs?: InputHTMLAttributes;
+    validationMessage?: string;
+}
+export declare const tagsInputParts: readonly ["root", "tags", "tag", "tagLabel", "tagRemove", "input", "clear"];
+export type TagsInputPart = (typeof tagsInputParts)[number];

package/dist/components/tags-input/useTagsInput.d.ts

@@ -0,0 +1,23 @@
+import { ComputedRef, Ref, SelectHTMLAttributes } from 'vue';
+import { ControlState } from '../../internal/composables/useControlState.js';
+import { TagsInputProps } from './types.js';
+export interface TagsInputControl {
+    templateRefs: {
+        root: Ref<HTMLElement | null>;
+        input: Ref<HTMLInputElement | null>;
+        native: Ref<HTMLSelectElement | null>;
+    };
+    nativeSelectAttrs: ComputedRef<SelectHTMLAttributes>;
+    control: ControlState;
+    rootClass: ComputedRef<string[]>;
+    values: ComputedRef<string[]>;
+    searchValue: Ref<string>;
+    canClear: ComputedRef<boolean>;
+    removeTag: (index: number) => void;
+    clear: () => void;
+    focusInput: (event?: MouseEvent) => void;
+    onInput: (event: Event) => void;
+    onInputBlur: (event: FocusEvent) => void;
+    onInputKeydown: (event: KeyboardEvent) => void;
+}
+export declare function useTagsInput(props: Readonly<TagsInputProps>, emitUpdate: (value: string[]) => void): TagsInputControl;

package/dist/components/teleport-provider/index.js

@@ -1,3 +1,3 @@
-import { r as useTeleportTarget } from "../../useTeleportTarget.js";
+import { n as useTeleportTarget } from "../../useTeleportTarget.js";
 import { t as teleport_provider_default } from "../../teleport-provider.js";
 export { teleport_provider_default as TeleportProvider, useTeleportTarget };

package/dist/components/teleport-provider/useTeleportTarget.d.ts

@@ -1,6 +1,5 @@
 import { ComputedRef, MaybeRefOrGetter } from 'vue';
 import { TeleportTarget, TeleportTargetValue } from '../floating/types.js';
 import { TeleportProviderProps } from './types.js';
-export declare function provideTeleportTarget(props: Readonly<TeleportProviderProps>, positioningKey?: MaybeRefOrGetter<unknown>): ComputedRef<TeleportTargetValue>;
+export declare function provideTeleportTarget(props: Readonly<TeleportProviderProps>): ComputedRef<TeleportTargetValue>;
 export declare function useTeleportTarget(target?: MaybeRefOrGetter<TeleportTarget | null | undefined>): ComputedRef<TeleportTargetValue>;
-export declare function useTeleportPositioningKey(): ComputedRef<unknown>;

package/dist/components/toast/useToastLifecycle.d.ts

@@ -0,0 +1,19 @@
+import { MaybeRefOrGetter } from 'vue';
+import { ToastCloseReason } from './types.js';
+interface UseToastLifecycleOptions {
+    isOpen: MaybeRefOrGetter<boolean>;
+    duration: MaybeRefOrGetter<number>;
+    pauseOnHover: MaybeRefOrGetter<boolean>;
+    pauseOnFocus: MaybeRefOrGetter<boolean>;
+    requestClose: (reason: ToastCloseReason) => void;
+}
+export declare function useToastLifecycle(options: Readonly<UseToastLifecycleOptions>): {
+    close: (reason: ToastCloseReason) => void;
+    rootEvents: {
+        onMouseenter: () => void;
+        onMouseleave: () => void;
+        onFocusin: () => void;
+        onFocusout: (event: FocusEvent) => void;
+    };
+};
+export {};

package/dist/components/tooltip/useTooltip.d.ts

@@ -1,7 +1,6 @@
 import { CSSProperties } from 'vue';
-import { TooltipOffset, TooltipProps, TooltipTriggerProps } from './types.js';
+import { TooltipProps, TooltipTriggerProps } from './types.js';
 type TooltipBehaviorProps = Omit<TooltipProps, 'classNames' | 'styles'>;
-export declare function resolveTooltipOffsetStyle(offset: TooltipOffset | undefined): CSSProperties | undefined;
 export declare function resolveTooltipColorStyleWithContrast(color: TooltipProps['color'], autoContrast: TooltipProps['autoContrast'], contrastColor?: TooltipProps['contrastColor']): CSSProperties | undefined;
 export declare function useTooltip(props: Readonly<TooltipBehaviorProps>, emitOpenChange?: (open: boolean) => void): {
     rootRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;

package/dist/components/tooltip/useTooltipTargetBindings.d.ts

@@ -0,0 +1,12 @@
+import { Ref } from 'vue';
+import { FloatingTargetLifecycle } from '../floating/useFloatingTargetLifecycle.js';
+interface UseTooltipTargetBindingsOptions {
+    targetLifecycle: FloatingTargetLifecycle;
+    shouldDescribeContent: Readonly<Ref<boolean>>;
+    tooltipId: Readonly<Ref<string>>;
+    openTooltip: () => void;
+    closeTooltip: () => void;
+    onKeydown: (event: KeyboardEvent) => void;
+}
+export declare function useTooltipTargetBindings({ targetLifecycle, shouldDescribeContent, tooltipId, openTooltip, closeTooltip, onKeydown, }: UseTooltipTargetBindingsOptions): void;
+export {};

package/dist/css.js

@@ -0,0 +1,12 @@
+//#region src/utils/css.ts
+function toCssLength(value) {
+	if (typeof value === "number") return Number.isFinite(value) ? `${value}px` : void 0;
+	if (typeof value !== "string") return void 0;
+	return value.trim() || void 0;
+}
+function toPositiveCssLength(value) {
+	if (typeof value === "number" && value <= 0) return void 0;
+	return toCssLength(value);
+}
+//#endregion
+export { toPositiveCssLength as n, toCssLength as t };

package/dist/date-picker.css

@@ -0,0 +1,49 @@
+@layer ropav.components {
+.rp-date-picker[data-v-c39b1387] {
+    display: inline-flex;
+    max-width: 100%;
+    font-family: var(--rp-font-family);
+    vertical-align: middle;
+}
+.rp-date-picker[data-v-c39b1387] .rp-input {
+    width: 100%;
+    min-width: 180px;
+}
+.rp-date-picker__clear[data-v-c39b1387], .rp-date-picker__indicator[data-v-c39b1387] {
+    padding: 0;
+    font: inherit;
+    background: none;
+    border: none;
+    cursor: pointer;
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    flex-shrink: 0;
+    border-radius: var(--rp-radius-xs);
+    color: var(--rp-color-control-icon);
+    transition: color var(--rp-transition-fast), opacity var(--rp-transition-fast);
+}
+.rp-date-picker__clear[data-v-c39b1387]:hover:not(:disabled), .rp-date-picker__indicator[data-v-c39b1387]:hover:not(:disabled) {
+    color: var(--rp-color-control-fg);
+}
+.rp-date-picker__clear[data-v-c39b1387]:focus-visible, .rp-date-picker__indicator[data-v-c39b1387]:focus-visible {
+    outline: var(--rp-border-width-medium) solid var(--rp-color-focus-ring);
+    outline-offset: 2px;
+}
+.rp-date-picker__clear[data-v-c39b1387]:disabled, .rp-date-picker__indicator[data-v-c39b1387]:disabled {
+    cursor: not-allowed;
+    opacity: var(--rp-opacity-disabled);
+}
+.rp-date-picker__clear[data-v-c39b1387] >  svg, .rp-date-picker__indicator[data-v-c39b1387] >  svg {
+    width: 1em;
+    height: 1em;
+}
+.rp-date-picker__clear--hidden[data-v-c39b1387] {
+    visibility: hidden;
+    pointer-events: none;
+}
+.rp-popover__content.rp-date-picker__popover {
+    min-width: auto;
+    padding: var(--rp-spacing-3);
+}
+}