@moubing/bing-ui 0.1.0 → 0.1.1

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

@@ -0,0 +1,21 @@
+export type BingAnimatedTextEffect = 'none' | 'shine' | 'jump';
+export type BingAnimatedTextTrigger = 'always' | 'hover' | 'once';
+export type BingAnimatedTextShineDirection = 'left' | 'right';
+export interface BingAnimatedTextProps {
+    effect?: BingAnimatedTextEffect;
+    trigger?: BingAnimatedTextTrigger;
+    disabled?: boolean;
+    shineColor?: string;
+    shineBaseColor?: string;
+    shineSpeed?: number;
+    shineDelay?: number;
+    shineInterval?: number;
+    shineDirection?: BingAnimatedTextShineDirection;
+    shineAngle?: number;
+    jumpY?: number;
+    jumpStagger?: number;
+    jumpDuration?: number;
+    jumpEase?: string;
+    jumpReturnEase?: string;
+    jumpRepeatDelay?: number;
+}

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

@@ -0,0 +1,31 @@
+import { BingAnimatedTextProps } from './BingAnimatedText.types';
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<BingAnimatedTextProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<BingAnimatedTextProps> & Readonly<{}>, {
+    effect: import('./BingAnimatedText.types').BingAnimatedTextEffect;
+    trigger: import('./BingAnimatedText.types').BingAnimatedTextTrigger;
+    disabled: boolean;
+    shineColor: string;
+    shineBaseColor: string;
+    shineSpeed: number;
+    shineDelay: number;
+    shineInterval: number;
+    shineDirection: import('./BingAnimatedText.types').BingAnimatedTextShineDirection;
+    shineAngle: number;
+    jumpY: number;
+    jumpStagger: number;
+    jumpDuration: number;
+    jumpEase: string;
+    jumpReturnEase: string;
+    jumpRepeatDelay: 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/BingAnimatedText/index.d.ts

@@ -0,0 +1,2 @@
+export { default as BingAnimatedText } from './BingAnimatedText.vue';
+export type { BingAnimatedTextEffect, BingAnimatedTextProps, BingAnimatedTextShineDirection, BingAnimatedTextTrigger, } from './BingAnimatedText.types';

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

@@ -0,0 +1,33 @@
+import { BingTabValue } from '../BingTabs';
+export interface BingAppSwitcherTransitionItem {
+    value: BingTabValue;
+    label: string;
+    disabled?: boolean;
+    ariaLabel?: string;
+    [key: string]: unknown;
+}
+export interface BingAppSwitcherTransitionProps {
+    modelValue?: BingTabValue;
+    items?: BingAppSwitcherTransitionItem[];
+    disabled?: boolean;
+    respectReducedMotion?: boolean;
+    loop?: boolean;
+    showTabs?: boolean;
+    ariaLabel?: string;
+}
+export interface BingAppSwitcherTransitionSlotProps {
+    item: BingAppSwitcherTransitionItem;
+    index: number;
+    active: boolean;
+    isAnimating: boolean;
+}
+export interface BingAppSwitcherTransitionChangePayload {
+    value: BingTabValue;
+    previousValue?: BingTabValue;
+    item: BingAppSwitcherTransitionItem;
+    previousItem?: BingAppSwitcherTransitionItem;
+}
+export interface BingAppSwitcherTransitionEmits {
+    'update:modelValue': [value: BingTabValue];
+    change: [payload: BingAppSwitcherTransitionChangePayload];
+}

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

@@ -0,0 +1,28 @@
+import { BingTabValue } from '../BingTabs';
+import { BingAppSwitcherTransitionProps, BingAppSwitcherTransitionSlotProps } from './BingAppSwitcherTransition.types';
+type __VLS_Slots = {
+    default?: (props: BingAppSwitcherTransitionSlotProps) => unknown;
+};
+declare const __VLS_base: import('vue').DefineComponent<BingAppSwitcherTransitionProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: BingTabValue) => any;
+    change: (payload: import('./BingAppSwitcherTransition.types').BingAppSwitcherTransitionChangePayload) => any;
+}, string, import('vue').PublicProps, Readonly<BingAppSwitcherTransitionProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: BingTabValue) => any) | undefined;
+    onChange?: ((payload: import('./BingAppSwitcherTransition.types').BingAppSwitcherTransitionChangePayload) => any) | undefined;
+}>, {
+    disabled: boolean;
+    ariaLabel: string;
+    modelValue: BingTabValue;
+    items: import('./BingAppSwitcherTransition.types').BingAppSwitcherTransitionItem[];
+    loop: boolean;
+    respectReducedMotion: boolean;
+    showTabs: boolean;
+}, {}, {}, {}, 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/BingAppSwitcherTransition/index.d.ts

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

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

@@ -0,0 +1,46 @@
+export type BingButtonVariant = 'primary' | 'secondary' | 'tertiary' | 'ghost' | 'danger' | 'success' | 'warning';
+export type BingButtonSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+export type BingButtonRounded = 'none' | 'sm' | 'md' | 'lg' | 'full';
+export type BingButtonHtmlType = 'button' | 'submit' | 'reset';
+export type BingButtonTextShine = 'none' | 'hover' | 'always';
+export type BingButtonTextEffect = 'none' | 'shine' | 'jump';
+export type BingButtonTextEffectTrigger = 'always' | 'hover';
+export type BingButtonShineDirection = 'left' | 'right';
+export interface BingButtonProps {
+    variant?: BingButtonVariant;
+    size?: BingButtonSize;
+    rounded?: BingButtonRounded;
+    htmlType?: BingButtonHtmlType;
+    disabled?: boolean;
+    loading?: boolean;
+    block?: boolean;
+    throttle?: boolean;
+    throttleDelay?: number;
+    textEffect?: BingButtonTextEffect;
+    textEffectTrigger?: BingButtonTextEffectTrigger;
+    textShine?: BingButtonTextShine;
+    shineColor?: string;
+    shineBaseColor?: string;
+    shineSpeed?: number;
+    shineDelay?: number;
+    shineInterval?: number;
+    shineDirection?: BingButtonShineDirection;
+    shineAngle?: number;
+    textJumpY?: number;
+    textJumpStagger?: number;
+    textJumpDuration?: number;
+    textJumpEase?: string;
+    textJumpReturnEase?: string;
+    textJumpRepeatDelay?: number;
+    ariaLabel?: string;
+}
+export interface BingButtonThrottledPayload {
+    event: MouseEvent;
+    remaining: number;
+}
+export interface BingButtonEmits {
+    click: [event: MouseEvent];
+    throttled: [payload: BingButtonThrottledPayload];
+    focus: [event: FocusEvent];
+    blur: [event: FocusEvent];
+}

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

@@ -0,0 +1,52 @@
+import { BingButtonProps } from './BingButton.types';
+declare var __VLS_1: {}, __VLS_9: {}, __VLS_11: {};
+type __VLS_Slots = {} & {
+    prefix?: (props: typeof __VLS_1) => any;
+} & {
+    default?: (props: typeof __VLS_9) => any;
+} & {
+    suffix?: (props: typeof __VLS_11) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<BingButtonProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    focus: (event: FocusEvent) => any;
+    blur: (event: FocusEvent) => any;
+    click: (event: MouseEvent) => any;
+    throttled: (payload: import('./BingButton.types').BingButtonThrottledPayload) => any;
+}, string, import('vue').PublicProps, Readonly<BingButtonProps> & Readonly<{
+    onFocus?: ((event: FocusEvent) => any) | undefined;
+    onBlur?: ((event: FocusEvent) => any) | undefined;
+    onClick?: ((event: MouseEvent) => any) | undefined;
+    onThrottled?: ((payload: import('./BingButton.types').BingButtonThrottledPayload) => any) | undefined;
+}>, {
+    disabled: boolean;
+    shineColor: string;
+    shineBaseColor: string;
+    shineSpeed: number;
+    shineDelay: number;
+    shineInterval: number;
+    shineDirection: import('./BingButton.types').BingButtonShineDirection;
+    shineAngle: number;
+    ariaLabel: string;
+    size: import('./BingButton.types').BingButtonSize;
+    variant: import('./BingButton.types').BingButtonVariant;
+    block: boolean;
+    rounded: import('./BingButton.types').BingButtonRounded;
+    htmlType: import('./BingButton.types').BingButtonHtmlType;
+    loading: boolean;
+    throttle: boolean;
+    throttleDelay: number;
+    textJumpY: number;
+    textJumpStagger: number;
+    textJumpDuration: number;
+    textJumpEase: string;
+    textJumpReturnEase: string;
+    textJumpRepeatDelay: 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/BingButton/index.d.ts

@@ -0,0 +1,2 @@
+export { default as BingButton } from './BingButton.vue';
+export type { BingButtonEmits, BingButtonHtmlType, BingButtonProps, BingButtonRounded, BingButtonSize, BingButtonTextEffect, BingButtonTextEffectTrigger, BingButtonTextShine, BingButtonThrottledPayload, BingButtonVariant, } from './BingButton.types';

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

@@ -0,0 +1,38 @@
+import { BingGlassEffectProps } from '../../utils/glass';
+export type BingCardVariant = 'plain' | 'soft' | 'accent' | 'sky';
+export type BingCardPadding = 'none' | 'sm' | 'md' | 'lg';
+export type BingCardRounded = 'none' | 'sm' | 'md' | 'lg' | 'xl' | 'full';
+export type BingCardEntrance = 'none' | 'fade-up' | 'bubble' | 'rotate-up' | 'soft-pop';
+export type BingCardFlipAxis = 'x' | 'y' | 'z';
+export type BingCardFlipSide = 'front' | 'back';
+export type BingCardFlipTrigger = 'none' | 'click' | 'press';
+export type BingCardLongPressRelease = 'restore' | 'stay';
+export interface BingCardProps extends BingGlassEffectProps {
+    title?: string;
+    description?: string;
+    variant?: BingCardVariant;
+    padding?: BingCardPadding;
+    rounded?: BingCardRounded;
+    glass?: boolean;
+    interactive?: boolean;
+    tilt?: boolean;
+    tiltMax?: number;
+    tiltScale?: number;
+    glare?: boolean;
+    entrance?: BingCardEntrance;
+    entranceOnce?: boolean;
+    entranceDelay?: number;
+    entranceDuration?: number;
+    flipAxis?: BingCardFlipAxis;
+    flipTurns?: number;
+    flipEase?: string;
+    flipTrigger?: BingCardFlipTrigger;
+    longPressDelay?: number;
+    longPressRelease?: BingCardLongPressRelease;
+    disabled?: boolean;
+}
+export interface BingCardEmits {
+    enter: [];
+    'long-press': [];
+    flip: [side: BingCardFlipSide];
+}

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

@@ -0,0 +1,56 @@
+import { BingCardFlipAxis, BingCardFlipTrigger, BingCardProps } from './BingCard.types';
+declare var __VLS_1: {}, __VLS_3: {}, __VLS_5: {}, __VLS_7: {}, __VLS_9: {};
+type __VLS_Slots = {} & {
+    media?: (props: typeof __VLS_1) => any;
+} & {
+    header?: (props: typeof __VLS_3) => any;
+} & {
+    default?: (props: typeof __VLS_5) => any;
+} & {
+    footer?: (props: typeof __VLS_7) => any;
+} & {
+    back?: (props: typeof __VLS_9) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<BingCardProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    enter: () => any;
+    "long-press": () => any;
+    flip: (side: import('./BingCard.types').BingCardFlipSide) => any;
+}, string, import('vue').PublicProps, Readonly<BingCardProps> & Readonly<{
+    onEnter?: (() => any) | undefined;
+    "onLong-press"?: (() => any) | undefined;
+    onFlip?: ((side: import('./BingCard.types').BingCardFlipSide) => any) | undefined;
+}>, {
+    disabled: boolean;
+    padding: import('./BingCard.types').BingCardPadding;
+    title: string;
+    glass: boolean;
+    variant: import('./BingCard.types').BingCardVariant;
+    rounded: import('./BingCard.types').BingCardRounded;
+    glassBlur: string | number;
+    glassOpacity: number;
+    glassSaturation: number;
+    description: string;
+    interactive: boolean;
+    tilt: boolean;
+    tiltMax: number;
+    tiltScale: number;
+    glare: boolean;
+    entrance: import('./BingCard.types').BingCardEntrance;
+    entranceOnce: boolean;
+    entranceDelay: number;
+    entranceDuration: number;
+    flipAxis: BingCardFlipAxis;
+    flipTurns: number;
+    flipEase: string;
+    flipTrigger: BingCardFlipTrigger;
+    longPressDelay: number;
+    longPressRelease: import('./BingCard.types').BingCardLongPressRelease;
+}, {}, {}, {}, 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/BingCard/index.d.ts

@@ -0,0 +1,2 @@
+export { default as BingCard } from './BingCard.vue';
+export type { BingCardEmits, BingCardEntrance, BingCardFlipAxis, BingCardFlipSide, BingCardLongPressRelease, BingCardPadding, BingCardProps, BingCardRounded, BingCardVariant, } from './BingCard.types';

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

@@ -0,0 +1,33 @@
+import { BingTabValue } from '../BingTabs';
+export interface BingCarouselTransitionItem {
+    value: BingTabValue;
+    label: string;
+    disabled?: boolean;
+    ariaLabel?: string;
+    [key: string]: unknown;
+}
+export interface BingCarouselTransitionProps {
+    modelValue?: BingTabValue;
+    items?: BingCarouselTransitionItem[];
+    disabled?: boolean;
+    respectReducedMotion?: boolean;
+    loop?: boolean;
+    showTabs?: boolean;
+    ariaLabel?: string;
+}
+export interface BingCarouselTransitionSlotProps {
+    item: BingCarouselTransitionItem;
+    index: number;
+    active: boolean;
+    isAnimating: boolean;
+}
+export interface BingCarouselTransitionChangePayload {
+    value: BingTabValue;
+    previousValue?: BingTabValue;
+    item: BingCarouselTransitionItem;
+    previousItem?: BingCarouselTransitionItem;
+}
+export interface BingCarouselTransitionEmits {
+    'update:modelValue': [value: BingTabValue];
+    change: [payload: BingCarouselTransitionChangePayload];
+}

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

@@ -0,0 +1,28 @@
+import { BingTabValue } from '../BingTabs';
+import { BingCarouselTransitionProps, BingCarouselTransitionSlotProps } from './BingCarouselTransition.types';
+type __VLS_Slots = {
+    default?: (props: BingCarouselTransitionSlotProps) => unknown;
+};
+declare const __VLS_base: import('vue').DefineComponent<BingCarouselTransitionProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: BingTabValue) => any;
+    change: (payload: import('./BingCarouselTransition.types').BingCarouselTransitionChangePayload) => any;
+}, string, import('vue').PublicProps, Readonly<BingCarouselTransitionProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: BingTabValue) => any) | undefined;
+    onChange?: ((payload: import('./BingCarouselTransition.types').BingCarouselTransitionChangePayload) => any) | undefined;
+}>, {
+    disabled: boolean;
+    ariaLabel: string;
+    modelValue: BingTabValue;
+    items: import('./BingCarouselTransition.types').BingCarouselTransitionItem[];
+    loop: boolean;
+    respectReducedMotion: boolean;
+    showTabs: boolean;
+}, {}, {}, {}, 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/BingCarouselTransition/index.d.ts

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

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

@@ -0,0 +1,25 @@
+export type BingCheckboxSize = 'sm' | 'md' | 'lg' | number;
+export type BingCheckboxShape = 'rounded' | 'circle';
+export type BingCheckboxTone = 'primary' | 'secondary';
+export interface BingCheckboxProps {
+    id?: string;
+    modelValue?: boolean;
+    indeterminate?: boolean;
+    disabled?: boolean;
+    size?: BingCheckboxSize;
+    shape?: BingCheckboxShape;
+    tone?: BingCheckboxTone;
+    label?: string;
+    ariaLabel?: string;
+    ariaDescribedby?: string;
+    status?: 'default' | 'error' | 'success' | 'warning';
+    name?: string;
+    value?: string | number;
+    decorative?: boolean;
+}
+export interface BingCheckboxEmits {
+    'update:modelValue': [value: boolean];
+    change: [value: boolean, event: Event];
+    focus: [event: FocusEvent];
+    blur: [event: FocusEvent];
+}

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

@@ -0,0 +1,39 @@
+import { BingCheckboxProps } from './BingCheckbox.types';
+declare var __VLS_13: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_13) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<BingCheckboxProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: boolean) => any;
+    change: (value: boolean, event: Event) => any;
+    focus: (event: FocusEvent) => any;
+    blur: (event: FocusEvent) => any;
+}, string, import('vue').PublicProps, Readonly<BingCheckboxProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+    onChange?: ((value: boolean, event: Event) => any) | undefined;
+    onFocus?: ((event: FocusEvent) => any) | undefined;
+    onBlur?: ((event: FocusEvent) => any) | undefined;
+}>, {
+    disabled: boolean;
+    label: string;
+    value: string | number;
+    ariaLabel: string;
+    modelValue: boolean;
+    size: import('./BingCheckbox.types').BingCheckboxSize;
+    name: string;
+    tone: import('./BingCheckbox.types').BingCheckboxTone;
+    decorative: boolean;
+    id: string;
+    indeterminate: boolean;
+    shape: import('./BingCheckbox.types').BingCheckboxShape;
+    ariaDescribedby: string;
+    status: "default" | "error" | "success" | "warning";
+}, {}, {}, {}, 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/BingCheckbox/index.d.ts

@@ -0,0 +1,2 @@
+export { default as BingCheckbox } from './BingCheckbox.vue';
+export type { BingCheckboxEmits, BingCheckboxProps, BingCheckboxShape, BingCheckboxSize, BingCheckboxTone, } from './BingCheckbox.types';

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

@@ -0,0 +1,13 @@
+import { ComputedRef, InjectionKey } from 'vue';
+import { BingCheckboxGroupOption, BingCheckboxGroupSize, BingCheckboxGroupValue } from './BingCheckboxGroup.types';
+export interface BingCheckboxGroupContext {
+    modelValue: ComputedRef<BingCheckboxGroupValue[]>;
+    disabled: ComputedRef<boolean>;
+    size: ComputedRef<BingCheckboxGroupSize>;
+    name: ComputedRef<string>;
+    status: ComputedRef<'default' | 'error' | 'success' | 'warning'>;
+    updateValue: (value: BingCheckboxGroupValue, checked: boolean, event: Event) => void;
+    handleCheckboxBlur: (event: FocusEvent) => void;
+    isOptionDisabled: (option: Pick<BingCheckboxGroupOption, 'disabled'>) => boolean;
+}
+export declare const bingCheckboxGroupContextKey: InjectionKey<BingCheckboxGroupContext>;

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

@@ -0,0 +1,27 @@
+export type BingCheckboxGroupValue = string | number;
+export type BingCheckboxGroupSize = 'sm' | 'md' | 'lg';
+export type BingCheckboxGroupDirection = 'row' | 'column' | 'wrap';
+export interface BingCheckboxGroupOption {
+    label: string;
+    value: BingCheckboxGroupValue;
+    disabled?: boolean;
+    description?: string;
+}
+export interface BingCheckboxGroupProps {
+    id?: string;
+    modelValue?: BingCheckboxGroupValue[];
+    options?: BingCheckboxGroupOption[];
+    disabled?: boolean;
+    size?: BingCheckboxGroupSize;
+    direction?: BingCheckboxGroupDirection;
+    name?: string;
+    ariaLabel?: string;
+    ariaDescribedby?: string;
+    status?: 'default' | 'error' | 'success' | 'warning';
+}
+export interface BingCheckboxGroupEmits {
+    'update:modelValue': [value: BingCheckboxGroupValue[]];
+    change: [value: BingCheckboxGroupValue[], event: Event];
+    focus: [event: FocusEvent];
+    blur: [event: FocusEvent];
+}

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

@@ -0,0 +1,35 @@
+import { BingCheckboxGroupOption, BingCheckboxGroupProps, BingCheckboxGroupValue } from './BingCheckboxGroup.types';
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<BingCheckboxGroupProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: BingCheckboxGroupValue[]) => any;
+    change: (value: BingCheckboxGroupValue[], event: Event) => any;
+    focus: (event: FocusEvent) => any;
+    blur: (event: FocusEvent) => any;
+}, string, import('vue').PublicProps, Readonly<BingCheckboxGroupProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: BingCheckboxGroupValue[]) => any) | undefined;
+    onChange?: ((value: BingCheckboxGroupValue[], event: Event) => any) | undefined;
+    onFocus?: ((event: FocusEvent) => any) | undefined;
+    onBlur?: ((event: FocusEvent) => any) | undefined;
+}>, {
+    disabled: boolean;
+    direction: import('./BingCheckboxGroup.types').BingCheckboxGroupDirection;
+    ariaLabel: string;
+    modelValue: BingCheckboxGroupValue[];
+    size: import('./BingCheckboxGroup.types').BingCheckboxGroupSize;
+    name: string;
+    id: string;
+    ariaDescribedby: string;
+    status: "default" | "error" | "success" | "warning";
+    options: BingCheckboxGroupOption[];
+}, {}, {}, {}, 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/BingCheckboxGroup/index.d.ts

@@ -0,0 +1,2 @@
+export { default as BingCheckboxGroup } from './BingCheckboxGroup.vue';
+export type { BingCheckboxGroupDirection, BingCheckboxGroupEmits, BingCheckboxGroupOption, BingCheckboxGroupProps, BingCheckboxGroupSize, BingCheckboxGroupValue, } from './BingCheckboxGroup.types';

package/dist/components/BingCodeBlock/BingCodeBlock.highlight.d.ts

@@ -0,0 +1,10 @@
+export interface BingCodeBlockToken {
+    content: string;
+    color?: string;
+    fontStyle?: number;
+}
+export interface BingCodeBlockLine {
+    number: number;
+    tokens: BingCodeBlockToken[];
+}
+export declare function highlightCode(code: string, language: string, theme: string): Promise<BingCodeBlockLine[]>;

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

@@ -0,0 +1,32 @@
+import { BingResizableProps } from '../BingResizable/BingResizable.types';
+export type BingCodeBlockHighlightLine = number | [number, number];
+export interface BingCodeBlockResizableOptions extends Pick<BingResizableProps, 'defaultSize' | 'minWidth' | 'minHeight' | 'maxWidth' | 'maxHeight' | 'mode' | 'snapMode' | 'directions' | 'step' | 'disabled' | 'lockAspectRatio' | 'contain' | 'showSize' | 'handleSize' | 'ariaLabel'> {
+}
+export interface BingCodeBlockProps {
+    code: string;
+    language?: string;
+    theme?: string;
+    title?: string;
+    languageLabel?: string;
+    copyable?: boolean;
+    copyLabel?: string;
+    copiedLabel?: string;
+    copyResetDelay?: number;
+    lineNumbers?: boolean;
+    highlightLines?: BingCodeBlockHighlightLine[];
+    width?: string | number;
+    maxHeight?: string | number;
+    resizable?: boolean;
+    resizableOptions?: BingCodeBlockResizableOptions;
+    wrap?: boolean;
+    ariaLabel?: string;
+}
+export interface BingCodeBlockCopyPayload {
+    code: string;
+    language: string;
+}
+export interface BingCodeBlockEmits {
+    copy: [payload: BingCodeBlockCopyPayload];
+    copyError: [error: Error];
+    highlightError: [error: Error];
+}

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

@@ -0,0 +1,29 @@
+import { BingCodeBlockHighlightLine, BingCodeBlockProps } from './BingCodeBlock.types';
+declare const __VLS_export: import('vue').DefineComponent<BingCodeBlockProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    copy: (payload: import('./BingCodeBlock.types').BingCodeBlockCopyPayload) => any;
+    copyError: (error: Error) => any;
+    highlightError: (error: Error) => any;
+}, string, import('vue').PublicProps, Readonly<BingCodeBlockProps> & Readonly<{
+    onCopy?: ((payload: import('./BingCodeBlock.types').BingCodeBlockCopyPayload) => any) | undefined;
+    onCopyError?: ((error: Error) => any) | undefined;
+    onHighlightError?: ((error: Error) => any) | undefined;
+}>, {
+    maxHeight: string | number;
+    width: string | number;
+    title: string;
+    ariaLabel: string;
+    wrap: boolean;
+    theme: string;
+    language: string;
+    languageLabel: string;
+    copyable: boolean;
+    copyLabel: string;
+    copiedLabel: string;
+    copyResetDelay: number;
+    lineNumbers: boolean;
+    highlightLines: BingCodeBlockHighlightLine[];
+    resizable: boolean;
+    resizableOptions: import('./BingCodeBlock.types').BingCodeBlockResizableOptions;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -0,0 +1,2 @@
+export { default as BingCodeBlock } from './BingCodeBlock.vue';
+export type { BingCodeBlockCopyPayload, BingCodeBlockEmits, BingCodeBlockHighlightLine, BingCodeBlockProps, BingCodeBlockResizableOptions, } from './BingCodeBlock.types';