@moubing/bing-ui 0.1.0 → 0.1.1

package/dist/components/BingDatePicker/BingDatePicker.types.d.ts

@@ -0,0 +1,70 @@
+import { Dayjs } from 'dayjs';
+import { BingGlassEffectProps } from '../../utils/glass';
+export type BingDatePickerType = 'date' | 'datetime' | 'month' | 'year' | 'time';
+export type BingDatePickerSize = 'sm' | 'md' | 'lg';
+export type BingDatePickerSingleValue = string | null;
+export type BingDatePickerRangeValue = [string, string] | null;
+export type BingDatePickerModelValue = BingDatePickerSingleValue | BingDatePickerRangeValue;
+export type BingDatePickerRangeRole = 'start' | 'end';
+export type BingDatePickerTimeUnit = 'hour' | 'minute' | 'second';
+export interface BingDatePickerDisabledDateContext {
+    type: BingDatePickerType;
+    range: boolean;
+    role?: BingDatePickerRangeRole;
+}
+export interface BingDatePickerDisabledTimeContext extends BingDatePickerDisabledDateContext {
+    unit: BingDatePickerTimeUnit;
+    value: number;
+}
+export interface BingDatePickerChangePayload {
+    value: BingDatePickerModelValue;
+    parsedValue: Dayjs | [Dayjs, Dayjs] | null;
+    type: BingDatePickerType;
+    range: boolean;
+}
+export interface BingDatePickerProps extends BingGlassEffectProps {
+    id?: string;
+    modelValue?: BingDatePickerModelValue;
+    type?: BingDatePickerType;
+    range?: boolean;
+    placeholder?: string;
+    startPlaceholder?: string;
+    endPlaceholder?: string;
+    disabled?: boolean;
+    clearable?: boolean;
+    size?: BingDatePickerSize;
+    block?: boolean;
+    minWidth?: string | number;
+    format?: string;
+    valueFormat?: string;
+    locale?: string;
+    firstDayOfWeek?: number;
+    min?: string;
+    max?: string;
+    disabledDate?: (value: Dayjs, context: BingDatePickerDisabledDateContext) => boolean;
+    disabledTime?: (value: Dayjs, context: BingDatePickerDisabledTimeContext) => boolean;
+    hourStep?: number;
+    minuteStep?: number;
+    secondStep?: number;
+    showShortcuts?: boolean;
+    panelMaxHeight?: string | number;
+    ariaLabel?: string;
+    ariaDescribedby?: string;
+    status?: 'default' | 'error' | 'success' | 'warning';
+}
+export interface BingDatePickerEmits {
+    'update:modelValue': [value: BingDatePickerModelValue];
+    change: [payload: BingDatePickerChangePayload];
+    clear: [];
+    open: [];
+    close: [];
+    confirm: [payload: BingDatePickerChangePayload];
+    cancel: [];
+}
+export interface BingDatePickerExpose {
+    focus: () => void;
+    blur: () => void;
+    openPanel: () => void;
+    closePanel: () => void;
+    clear: () => void;
+}

package/dist/components/BingDatePicker/BingDatePicker.vue.d.ts

@@ -0,0 +1,54 @@
+import { Dayjs } from 'dayjs';
+import { BingDatePickerChangePayload, BingDatePickerExpose, BingDatePickerModelValue, BingDatePickerProps, BingDatePickerType } from './BingDatePicker.types';
+declare const __VLS_export: import('vue').DefineComponent<BingDatePickerProps, BingDatePickerExpose, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    clear: () => any;
+    "update:modelValue": (value: BingDatePickerModelValue) => any;
+    change: (payload: BingDatePickerChangePayload) => any;
+    cancel: () => any;
+    close: () => any;
+    open: () => any;
+    confirm: (payload: BingDatePickerChangePayload) => any;
+}, string, import('vue').PublicProps, Readonly<BingDatePickerProps> & Readonly<{
+    onClear?: (() => any) | undefined;
+    "onUpdate:modelValue"?: ((value: BingDatePickerModelValue) => any) | undefined;
+    onChange?: ((payload: BingDatePickerChangePayload) => any) | undefined;
+    onCancel?: (() => any) | undefined;
+    onClose?: (() => any) | undefined;
+    onOpen?: (() => any) | undefined;
+    onConfirm?: ((payload: BingDatePickerChangePayload) => any) | undefined;
+}>, {
+    disabled: boolean;
+    minWidth: string | number;
+    type: BingDatePickerType;
+    glass: boolean;
+    ariaLabel: string;
+    modelValue: BingDatePickerModelValue;
+    size: import('./BingDatePicker.types').BingDatePickerSize;
+    block: boolean;
+    glassBlur: string | number;
+    glassOpacity: number;
+    glassSaturation: number;
+    id: string;
+    ariaDescribedby: string;
+    status: "default" | "error" | "success" | "warning";
+    range: boolean;
+    max: string;
+    min: string;
+    format: string;
+    placeholder: string;
+    startPlaceholder: string;
+    endPlaceholder: string;
+    clearable: boolean;
+    valueFormat: string;
+    locale: string;
+    firstDayOfWeek: number;
+    disabledDate: (value: Dayjs, context: import('./BingDatePicker.types').BingDatePickerDisabledDateContext) => boolean;
+    disabledTime: (value: Dayjs, context: import('./BingDatePicker.types').BingDatePickerDisabledTimeContext) => boolean;
+    hourStep: number;
+    minuteStep: number;
+    secondStep: number;
+    showShortcuts: boolean;
+    panelMaxHeight: string | number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/BingDatePicker/index.d.ts

@@ -0,0 +1,2 @@
+export { default as BingDatePicker } from './BingDatePicker.vue';
+export type { BingDatePickerChangePayload, BingDatePickerDisabledDateContext, BingDatePickerDisabledTimeContext, BingDatePickerEmits, BingDatePickerExpose, BingDatePickerModelValue, BingDatePickerProps, BingDatePickerRangeRole, BingDatePickerRangeValue, BingDatePickerSingleValue, BingDatePickerSize, BingDatePickerTimeUnit, BingDatePickerType, } from './BingDatePicker.types';

package/dist/components/BingDeckTransition/BingDeckTransition.types.d.ts

@@ -0,0 +1,38 @@
+import { BingTabValue } from '../BingTabs';
+export interface BingDeckTransitionItem {
+    value: BingTabValue;
+    label: string;
+    disabled?: boolean;
+    [key: string]: unknown;
+}
+export interface BingDeckTransitionProps {
+    modelValue?: BingTabValue;
+    items?: BingDeckTransitionItem[];
+    disabled?: boolean;
+    respectReducedMotion?: boolean;
+    loop?: boolean;
+    showControls?: boolean;
+    controlLabel?: string;
+}
+export interface BingDeckTransitionSlotProps {
+    item: BingDeckTransitionItem;
+    index: number;
+    active: boolean;
+    isAnimating: boolean;
+}
+export interface BingDeckTransitionControlsSlotProps {
+    next: () => void;
+    activeItem?: BingDeckTransitionItem;
+    activeIndex: number;
+    isAnimating: boolean;
+}
+export interface BingDeckTransitionChangePayload {
+    value: BingTabValue;
+    previousValue?: BingTabValue;
+    item: BingDeckTransitionItem;
+    previousItem?: BingDeckTransitionItem;
+}
+export interface BingDeckTransitionEmits {
+    'update:modelValue': [value: BingTabValue];
+    change: [payload: BingDeckTransitionChangePayload];
+}

package/dist/components/BingDeckTransition/BingDeckTransition.vue.d.ts

@@ -0,0 +1,29 @@
+import { BingTabValue } from '../BingTabs';
+import { BingDeckTransitionControlsSlotProps, BingDeckTransitionProps, BingDeckTransitionSlotProps } from './BingDeckTransition.types';
+type __VLS_Slots = {
+    default?: (props: BingDeckTransitionSlotProps) => unknown;
+    controls?: (props: BingDeckTransitionControlsSlotProps) => unknown;
+};
+declare const __VLS_base: import('vue').DefineComponent<BingDeckTransitionProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: BingTabValue) => any;
+    change: (payload: import('./BingDeckTransition.types').BingDeckTransitionChangePayload) => any;
+}, string, import('vue').PublicProps, Readonly<BingDeckTransitionProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: BingTabValue) => any) | undefined;
+    onChange?: ((payload: import('./BingDeckTransition.types').BingDeckTransitionChangePayload) => any) | undefined;
+}>, {
+    disabled: boolean;
+    modelValue: BingTabValue;
+    items: import('./BingDeckTransition.types').BingDeckTransitionItem[];
+    loop: boolean;
+    respectReducedMotion: boolean;
+    showControls: boolean;
+    controlLabel: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/BingDeckTransition/index.d.ts

@@ -0,0 +1,2 @@
+export { default as BingDeckTransition } from './BingDeckTransition.vue';
+export * from './BingDeckTransition.types';

package/dist/components/BingDialog/BingDialog.types.d.ts

@@ -0,0 +1,45 @@
+import { BingGlassEffectProps } from '../../utils/glass';
+export type BingDialogCloseReason = 'close' | 'cancel' | 'overlay' | 'escape' | 'confirm';
+export interface BingDialogOverlayOrb {
+    id?: string;
+    color: string;
+    x?: number;
+    y?: number;
+    size?: number | string;
+    opacity?: number;
+    blur?: number;
+    motionX?: number;
+    motionY?: number;
+    duration?: number;
+    delay?: number;
+}
+export interface BingDialogProps extends BingGlassEffectProps {
+    modelValue?: boolean;
+    title?: string;
+    width?: string | number;
+    zIndex?: number;
+    lockScroll?: boolean;
+    closeOnOverlay?: boolean;
+    closeOnEsc?: boolean;
+    closeOnConfirm?: boolean;
+    showClose?: boolean;
+    showFooter?: boolean;
+    cancelText?: string;
+    confirmText?: string;
+    confirmLoading?: boolean;
+    confirmDisabled?: boolean;
+    glass?: boolean;
+    overlayBlur?: boolean;
+    overlayOrbs?: BingDialogOverlayOrb[];
+    overlayOrbsAnimated?: boolean;
+    showPeek?: boolean;
+    peekOpacity?: number;
+    ariaLabel?: string;
+    ariaDescribedby?: string;
+}
+export interface BingDialogEmits {
+    'update:modelValue': [value: boolean];
+    close: [reason: BingDialogCloseReason];
+    cancel: [];
+    confirm: [];
+}

package/dist/components/BingDialog/BingDialog.vue.d.ts

@@ -0,0 +1,61 @@
+import { BingDialogCloseReason, BingDialogOverlayOrb, BingDialogProps } from './BingDialog.types';
+declare function closeDialog(reason: BingDialogCloseReason): void;
+declare function handleCancel(): void;
+declare function handleConfirm(): void;
+declare var __VLS_7: {}, __VLS_28: {}, __VLS_30: {
+    close: typeof closeDialog;
+    cancel: typeof handleCancel;
+    confirm: typeof handleConfirm;
+};
+type __VLS_Slots = {} & {
+    title?: (props: typeof __VLS_7) => any;
+} & {
+    default?: (props: typeof __VLS_28) => any;
+} & {
+    footer?: (props: typeof __VLS_30) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<BingDialogProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: boolean) => any;
+    cancel: () => any;
+    close: (reason: BingDialogCloseReason) => any;
+    confirm: () => any;
+}, string, import('vue').PublicProps, Readonly<BingDialogProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+    onCancel?: (() => any) | undefined;
+    onClose?: ((reason: BingDialogCloseReason) => any) | undefined;
+    onConfirm?: (() => any) | undefined;
+}>, {
+    width: string | number;
+    zIndex: number;
+    title: string;
+    glass: boolean;
+    ariaLabel: string;
+    modelValue: boolean;
+    glassBlur: string | number;
+    glassOpacity: number;
+    glassSaturation: number;
+    ariaDescribedby: string;
+    closeOnEsc: boolean;
+    lockScroll: boolean;
+    closeOnOverlay: boolean;
+    closeOnConfirm: boolean;
+    showClose: boolean;
+    showFooter: boolean;
+    cancelText: string;
+    confirmText: string;
+    confirmLoading: boolean;
+    confirmDisabled: boolean;
+    overlayBlur: boolean;
+    overlayOrbs: BingDialogOverlayOrb[];
+    overlayOrbsAnimated: boolean;
+    showPeek: boolean;
+    peekOpacity: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/BingDialog/index.d.ts

@@ -0,0 +1,2 @@
+export { default as BingDialog } from './BingDialog.vue';
+export type { BingDialogCloseReason, BingDialogEmits, BingDialogOverlayOrb, BingDialogProps, } from './BingDialog.types';

package/dist/components/BingDropDown/BingDropDown.context.d.ts

@@ -0,0 +1,7 @@
+import { InjectionKey } from 'vue';
+export interface BingDropDownContext {
+    close: () => void;
+    floatingId: string;
+    getGlassStyle: () => Record<string, string>;
+}
+export declare const bingDropDownContextKey: InjectionKey<BingDropDownContext>;

package/dist/components/BingDropDown/BingDropDown.types.d.ts

@@ -0,0 +1,60 @@
+import { Component } from 'vue';
+import { BingGlassEffectProps } from '../../utils/glass';
+export type BingDropDownPlacement = 'bottom-start' | 'bottom-end' | 'top-start' | 'top-end' | 'left-start' | 'left-end' | 'right-start' | 'right-end';
+export type BingDropDownSize = 'sm' | 'md' | 'lg';
+export type BingDropDownTrigger = 'click' | 'hover' | 'contextmenu';
+export type BingDropDownItemTone = 'default' | 'primary' | 'secondary' | 'danger' | 'success' | 'warning';
+export interface BingDropDownProps extends BingGlassEffectProps {
+    open?: boolean | null;
+    context?: unknown | null;
+    trigger?: BingDropDownTrigger;
+    placement?: BingDropDownPlacement;
+    size?: BingDropDownSize;
+    width?: string | number;
+    minWidth?: string | number;
+    maxWidth?: string | number;
+    block?: boolean;
+    closeOnOutside?: boolean;
+    closeOnEscape?: boolean;
+    autoFocus?: boolean;
+    loop?: boolean;
+    ariaLabel?: string;
+}
+export interface BingDropDownContextOpenPayload {
+    event: MouseEvent | KeyboardEvent;
+    context: unknown | null;
+    x: number;
+    y: number;
+}
+export interface BingDropDownEmits {
+    'update:open': [open: boolean];
+    'update:context': [context: unknown | null];
+    open: [];
+    close: [];
+    'context-open': [payload: BingDropDownContextOpenPayload];
+    'after-enter': [];
+    'after-leave': [];
+}
+export interface BingDropDownExpose {
+    openPanel: () => void;
+    close: () => void;
+    toggle: () => void;
+    focusFirstItem: () => void;
+}
+export interface BingDropDownItemProps {
+    title?: string;
+    description?: string;
+    shortcut?: string | string[];
+    icon?: Component;
+    href?: string;
+    target?: string;
+    rel?: string;
+    tone?: BingDropDownItemTone;
+    disabled?: boolean;
+    active?: boolean;
+    closeOnClick?: boolean;
+    ariaLabel?: string;
+}
+export interface BingDropDownItemEmits {
+    click: [event: MouseEvent];
+}

package/dist/components/BingDropDown/BingDropDown.vue.d.ts

@@ -0,0 +1,87 @@
+import { BingDropDownExpose, BingDropDownPlacement, BingDropDownProps } from './BingDropDown.types';
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: __VLS_WithSlots<import('vue').DefineComponent<BingDropDownProps, BingDropDownExpose, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    close: () => any;
+    open: () => any;
+    "update:open": (open: boolean) => any;
+    "update:context": (context: unknown) => any;
+    "context-open": (payload: import('./BingDropDown.types').BingDropDownContextOpenPayload) => any;
+    "after-enter": () => any;
+    "after-leave": () => any;
+}, string, import('vue').PublicProps, Readonly<BingDropDownProps> & Readonly<{
+    onClose?: (() => any) | undefined;
+    onOpen?: (() => any) | undefined;
+    "onUpdate:open"?: ((open: boolean) => any) | undefined;
+    "onUpdate:context"?: ((context: unknown) => any) | undefined;
+    "onContext-open"?: ((payload: import('./BingDropDown.types').BingDropDownContextOpenPayload) => any) | undefined;
+    "onAfter-enter"?: (() => any) | undefined;
+    "onAfter-leave"?: (() => any) | undefined;
+}>, {
+    trigger: import('./BingDropDown.types').BingDropDownTrigger;
+    glass: boolean;
+    ariaLabel: string;
+    size: import('./BingDropDown.types').BingDropDownSize;
+    block: boolean;
+    loop: boolean;
+    glassBlur: string | number;
+    glassOpacity: number;
+    glassSaturation: number;
+    placement: BingDropDownPlacement;
+    closeOnOutside: boolean;
+    open: boolean | null;
+    closeOnEscape: boolean;
+    autoFocus: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>, {
+    trigger?: (props: {
+        open: boolean;
+        context: unknown;
+        openPanel: () => void;
+        triggerProps: {
+            onContextmenu: (event: MouseEvent) => void;
+            onKeydown: (event: KeyboardEvent) => void;
+            'aria-expanded': "true" | "false";
+            'aria-haspopup': "menu";
+            'data-bing-dropdown-trigger': string;
+        } | {
+            onClick: (event: MouseEvent) => void;
+            onKeydown: (event: KeyboardEvent) => void;
+            onPointerenter: (event: PointerEvent) => void;
+            onPointerleave: (event: PointerEvent) => void;
+            'aria-expanded': "true" | "false";
+            'aria-haspopup': "menu";
+            'data-bing-dropdown-trigger': string;
+        };
+        getTriggerProps: (context?: unknown | null) => {
+            onContextmenu: (event: MouseEvent) => void;
+            onKeydown: (event: KeyboardEvent) => void;
+            'aria-expanded': "true" | "false";
+            'aria-haspopup': "menu";
+            'data-bing-dropdown-trigger': string;
+        } | {
+            onClick: (event: MouseEvent) => void;
+            onKeydown: (event: KeyboardEvent) => void;
+            onPointerenter: (event: PointerEvent) => void;
+            onPointerleave: (event: PointerEvent) => void;
+            'aria-expanded': "true" | "false";
+            'aria-haspopup': "menu";
+            'data-bing-dropdown-trigger': string;
+        };
+        close: (restoreFocus?: boolean) => void;
+        toggle: () => void;
+    }) => any;
+} & {
+    header?: (props: {}) => any;
+} & {
+    default?: (props: {
+        context: unknown;
+        close: (restoreFocus?: boolean) => void;
+    }) => any;
+} & {
+    footer?: (props: {}) => any;
+}>;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/BingDropDown/BingDropDownItem.vue.d.ts

@@ -0,0 +1,36 @@
+import { BingDropDownItemProps } from './BingDropDown.types';
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: __VLS_WithSlots<import('vue').DefineComponent<BingDropDownItemProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    click: (event: MouseEvent) => any;
+}, string, import('vue').PublicProps, Readonly<BingDropDownItemProps> & Readonly<{
+    onClick?: ((event: MouseEvent) => any) | undefined;
+}>, {
+    disabled: boolean;
+    title: string;
+    ariaLabel: string;
+    description: string;
+    icon: import('vue').Component;
+    tone: import('./BingDropDown.types').BingDropDownItemTone;
+    target: string;
+    href: string;
+    shortcut: string | string[];
+    rel: string;
+    active: boolean;
+    closeOnClick: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>, {
+    prefix?: (props: {}) => any;
+} & {
+    default?: (props: {}) => any;
+} & {
+    description?: (props: {}) => any;
+} & {
+    suffix?: (props: {}) => any;
+} & {
+    submenu?: (props: {}) => any;
+}>;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/BingDropDown/index.d.ts

@@ -0,0 +1,3 @@
+export { default as BingDropDown } from './BingDropDown.vue';
+export { default as BingDropDownItem } from './BingDropDownItem.vue';
+export type { BingDropDownEmits, BingDropDownContextOpenPayload, BingDropDownExpose, BingDropDownItemEmits, BingDropDownItemProps, BingDropDownItemTone, BingDropDownPlacement, BingDropDownProps, BingDropDownSize, BingDropDownTrigger, } from './BingDropDown.types';

package/dist/components/BingFilePreview/BingFilePreview.types.d.ts

@@ -0,0 +1,56 @@
+import { BingGlassEffectProps } from '../../utils/glass';
+export type BingFilePreviewKind = 'auto' | 'image' | 'pdf' | 'text' | 'json' | 'csv' | 'docx' | 'xlsx' | 'pptx' | 'office' | 'unknown';
+export type BingFilePreviewResolvedKind = Exclude<BingFilePreviewKind, 'auto'>;
+export type BingFilePreviewCloseReason = 'close' | 'overlay' | 'escape';
+export interface BingFilePreviewFile {
+    src?: string;
+    name?: string;
+    type?: BingFilePreviewKind;
+    mimeType?: string;
+    previewSrc?: string;
+    content?: string;
+    downloadUrl?: string;
+    size?: number;
+}
+export interface BingFilePreviewProps extends BingGlassEffectProps {
+    modelValue?: boolean;
+    file?: BingFilePreviewFile;
+    src?: string;
+    name?: string;
+    type?: BingFilePreviewKind;
+    mimeType?: string;
+    previewSrc?: string;
+    content?: string;
+    downloadUrl?: string;
+    size?: number;
+    zIndex?: number;
+    width?: string | number;
+    height?: string | number;
+    lockScroll?: boolean;
+    closeOnEsc?: boolean;
+    closeOnOverlay?: boolean;
+    downloadable?: boolean;
+    openable?: boolean;
+    jsonHighlight?: boolean;
+    jsonHighlightMaxLength?: number;
+    textMaxLength?: number;
+    csvMaxRows?: number;
+    csvMaxColumns?: number;
+    teleportTo?: string | HTMLElement;
+    ariaLabel?: string;
+}
+export interface BingFilePreviewDownloadPayload {
+    file: BingFilePreviewFile;
+    kind: BingFilePreviewResolvedKind;
+}
+export interface BingFilePreviewOpenExternalPayload {
+    file: BingFilePreviewFile;
+    kind: BingFilePreviewResolvedKind;
+}
+export interface BingFilePreviewEmits {
+    'update:modelValue': [value: boolean];
+    close: [reason: BingFilePreviewCloseReason];
+    download: [payload: BingFilePreviewDownloadPayload];
+    openExternal: [payload: BingFilePreviewOpenExternalPayload];
+    error: [error: Error];
+}

package/dist/components/BingFilePreview/BingFilePreview.vue.d.ts

@@ -0,0 +1,46 @@
+import { BingFilePreviewCloseReason, BingFilePreviewFile, BingFilePreviewProps } from './BingFilePreview.types';
+declare const __VLS_export: import('vue').DefineComponent<BingFilePreviewProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: boolean) => any;
+    error: (error: Error) => any;
+    close: (reason: BingFilePreviewCloseReason) => any;
+    download: (payload: import('./BingFilePreview.types').BingFilePreviewDownloadPayload) => any;
+    openExternal: (payload: import('./BingFilePreview.types').BingFilePreviewOpenExternalPayload) => any;
+}, string, import('vue').PublicProps, Readonly<BingFilePreviewProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+    onError?: ((error: Error) => any) | undefined;
+    onClose?: ((reason: BingFilePreviewCloseReason) => any) | undefined;
+    onDownload?: ((payload: import('./BingFilePreview.types').BingFilePreviewDownloadPayload) => any) | undefined;
+    onOpenExternal?: ((payload: import('./BingFilePreview.types').BingFilePreviewOpenExternalPayload) => any) | undefined;
+}>, {
+    content: string;
+    height: string | number;
+    width: string | number;
+    zIndex: number;
+    type: import('./BingFilePreview.types').BingFilePreviewKind;
+    glass: boolean;
+    ariaLabel: string;
+    modelValue: boolean;
+    size: number;
+    name: string;
+    glassBlur: string | number;
+    glassOpacity: number;
+    glassSaturation: number;
+    file: BingFilePreviewFile;
+    closeOnEsc: boolean;
+    lockScroll: boolean;
+    closeOnOverlay: boolean;
+    downloadable: boolean;
+    teleportTo: string | HTMLElement;
+    src: string;
+    mimeType: string;
+    previewSrc: string;
+    downloadUrl: string;
+    openable: boolean;
+    jsonHighlight: boolean;
+    jsonHighlightMaxLength: number;
+    textMaxLength: number;
+    csvMaxRows: number;
+    csvMaxColumns: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/BingFilePreview/index.d.ts

@@ -0,0 +1,2 @@
+export { default as BingFilePreview } from './BingFilePreview.vue';
+export type { BingFilePreviewCloseReason, BingFilePreviewDownloadPayload, BingFilePreviewEmits, BingFilePreviewFile, BingFilePreviewKind, BingFilePreviewOpenExternalPayload, BingFilePreviewProps, BingFilePreviewResolvedKind, } from './BingFilePreview.types';

package/dist/components/BingForm/BingForm.context.d.ts

@@ -0,0 +1,31 @@
+import { ComputedRef, InjectionKey } from 'vue';
+import { BingControlStatus, BingFormBreakpoint, BingFormErrors, BingFormLabelPosition, BingFormSize, BingFormValidateTrigger } from './BingForm.types';
+export interface BingFormFieldRegistration {
+    prop: string;
+    scrollToField: () => void;
+}
+export interface BingFormContext {
+    size: ComputedRef<BingFormSize>;
+    disabled: ComputedRef<boolean>;
+    columns: ComputedRef<Record<BingFormBreakpoint, number>>;
+    labelPosition: ComputedRef<BingFormLabelPosition>;
+    labelWidth: ComputedRef<string>;
+    validateField: (prop: string, trigger?: BingFormValidateTrigger) => Promise<boolean>;
+    clearValidate: (prop?: string) => void;
+    getFieldErrors: (prop: string) => string[];
+    registerField: (field: BingFormFieldRegistration) => void;
+    unregisterField: (field: BingFormFieldRegistration) => void;
+}
+export interface BingFormItemContext {
+    controlId: ComputedRef<string>;
+    ariaDescribedby: ComputedRef<string | undefined>;
+    isInvalid: ComputedRef<boolean>;
+    status: ComputedRef<BingControlStatus>;
+    size: ComputedRef<BingFormSize>;
+    disabled: ComputedRef<boolean>;
+    handleControlChange: () => void;
+    handleControlBlur: () => void;
+}
+export declare const bingFormContextKey: InjectionKey<BingFormContext>;
+export declare const bingFormItemContextKey: InjectionKey<BingFormItemContext>;
+export declare function cloneErrors(errors: BingFormErrors): BingFormErrors;