@dialpad/dialtone-vue 4.4.1 → 4.6.0

package/dist/components/Slider/Composables/UseSliderDevWarnings.d.ts

@@ -0,0 +1,5 @@
+export function useSliderDevWarnings(props: any, { isRange, hasAccessibleName }: {
+    isRange: any;
+    hasAccessibleName: any;
+}): void;
+//# sourceMappingURL=UseSliderDevWarnings.d.ts.map

package/dist/components/Slider/Composables/UseSliderDevWarnings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UseSliderDevWarnings.d.ts","sourceRoot":"","sources":["../../../../components/Slider/Composables/UseSliderDevWarnings.js"],"names":[],"mappings":"AASA;;;SAyDC"}

package/dist/components/Slider/Composables/UseSliderDirection.d.ts

@@ -0,0 +1,4 @@
+export function useSliderDirection(controlRef: any): {
+    isRtl: import('vue').Ref<boolean, boolean>;
+};
+//# sourceMappingURL=UseSliderDirection.d.ts.map

package/dist/components/Slider/Composables/UseSliderDirection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UseSliderDirection.d.ts","sourceRoot":"","sources":["../../../../components/Slider/Composables/UseSliderDirection.js"],"names":[],"mappings":"AAOA;;EAgDC"}

package/dist/components/Slider/Composables/UseSliderGeometry.d.ts

@@ -0,0 +1,88 @@
+export function useSliderGeometry(props: any, { isVertical, isRange, internalValues, thumbPercent, isRtl, markEdgeOffsetPx, formatValue, }: {
+    isVertical: any;
+    isRange: any;
+    internalValues: any;
+    thumbPercent: any;
+    isRtl: any;
+    markEdgeOffsetPx: any;
+    formatValue: any;
+}): {
+    thumbPositionStyle: (val: any) => {
+        bottom: string;
+        transform: any;
+        insetInlineStart?: undefined;
+    } | {
+        insetInlineStart: string;
+        transform: any;
+        bottom?: undefined;
+    };
+    tickPositionStyle: (val: any) => {
+        bottom: string;
+        transform: any;
+        insetInlineStart?: undefined;
+    } | {
+        insetInlineStart: string;
+        transform: any;
+        bottom?: undefined;
+    };
+    markStyle: (pct: any, index: any, edge: any) => {
+        bottom: string;
+        insetInlineStart?: undefined;
+    } | {
+        insetInlineStart: string;
+        bottom?: undefined;
+    };
+    readoutStyle: (pct: any, offsetPx: any, edge: any) => {
+        bottom: string;
+        insetInlineStart?: undefined;
+    } | {
+        insetInlineStart: string;
+        bottom?: undefined;
+    };
+    mergedReadoutPct: import('vue').ComputedRef<number>;
+    mergedReadoutText: import('vue').ComputedRef<string>;
+    indicatorStyle: import('vue').ComputedRef<{
+        bottom: string;
+        height: string;
+        insetInlineStart?: undefined;
+        width?: undefined;
+        top?: undefined;
+        insetInlineEnd?: undefined;
+    } | {
+        insetInlineStart: string;
+        width: string;
+        bottom?: undefined;
+        height?: undefined;
+        top?: undefined;
+        insetInlineEnd?: undefined;
+    } | {
+        top: number;
+        height: string;
+        bottom?: undefined;
+        insetInlineStart?: undefined;
+        width?: undefined;
+        insetInlineEnd?: undefined;
+    } | {
+        bottom: number;
+        height: string;
+        insetInlineStart?: undefined;
+        width?: undefined;
+        top?: undefined;
+        insetInlineEnd?: undefined;
+    } | {
+        insetInlineEnd: number;
+        width: string;
+        bottom?: undefined;
+        height?: undefined;
+        insetInlineStart?: undefined;
+        top?: undefined;
+    } | {
+        insetInlineStart: number;
+        width: string;
+        bottom?: undefined;
+        height?: undefined;
+        top?: undefined;
+        insetInlineEnd?: undefined;
+    }>;
+};
+//# sourceMappingURL=UseSliderGeometry.d.ts.map

package/dist/components/Slider/Composables/UseSliderGeometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UseSliderGeometry.d.ts","sourceRoot":"","sources":["../../../../components/Slider/Composables/UseSliderGeometry.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkPC"}

package/dist/components/Slider/Composables/UseSliderInteraction.d.ts

@@ -0,0 +1,33 @@
+export function useSliderInteraction(props: any, emit: any, { controlRef, thumbRefs, internalValues, isRange, isVertical, decimalPlaces, snapToStep, lastCommittedValues, findMagneticSnapPoint, activeSnapValue, isRtl, }: {
+    controlRef: any;
+    thumbRefs: any;
+    internalValues: any;
+    isRange: any;
+    isVertical: any;
+    decimalPlaces: any;
+    snapToStep: any;
+    lastCommittedValues: any;
+    findMagneticSnapPoint: any;
+    activeSnapValue: any;
+    isRtl: any;
+}): {
+    isDragging: import('vue').Ref<boolean, boolean>;
+    activeThumbIndex: import('vue').Ref<null, null>;
+    focusedThumbIndex: import('vue').Ref<null, null>;
+    hoveredThumbIndex: import('vue').Ref<null, null>;
+    updateThumbValue: (thumbIndex: any, newVal: any, { allowSnap }?: {
+        allowSnap?: boolean | undefined;
+    }) => void;
+    commitIfChanged: () => void;
+    onPointerDown: (event: any) => void;
+    onPointerMove: (event: any) => void;
+    onPointerUp: (event: any) => void;
+    onThumbInput: (i: any, event: any) => void;
+    onThumbKeydown: (i: any, event: any) => void;
+    onThumbFocus: (i: any, event: any) => void;
+    onThumbBlur: (i: any, event: any) => void;
+    onThumbHitPointerEnter: (i: any) => void;
+    onThumbHitPointerLeave: (i: any) => void;
+    isReadoutOpen: (i: any) => boolean;
+};
+//# sourceMappingURL=UseSliderInteraction.d.ts.map

package/dist/components/Slider/Composables/UseSliderInteraction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UseSliderInteraction.d.ts","sourceRoot":"","sources":["../../../../components/Slider/Composables/UseSliderInteraction.js"],"names":[],"mappings":"AAeA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6eC"}

package/dist/components/Slider/Composables/UseSliderMagneticSnap.d.ts

@@ -0,0 +1,8 @@
+export function useSliderMagneticSnap(props: any, { controlRef, isVertical }: {
+    controlRef: any;
+    isVertical: any;
+}): {
+    activeSnapValue: import('vue').Ref<{}, {}>;
+    findMagneticSnapPoint: (rawVal: any, thumbIndex: any) => any;
+};
+//# sourceMappingURL=UseSliderMagneticSnap.d.ts.map

package/dist/components/Slider/Composables/UseSliderMagneticSnap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UseSliderMagneticSnap.d.ts","sourceRoot":"","sources":["../../../../components/Slider/Composables/UseSliderMagneticSnap.js"],"names":[],"mappings":"AAaA;;;;;;EA4EC"}

package/dist/components/Slider/Composables/UseSliderMarksAndTicks.d.ts

@@ -0,0 +1,13 @@
+export function useSliderMarksAndTicks(props: any, { isVertical, thumbPercent }: {
+    isVertical: any;
+    thumbPercent: any;
+}): {
+    computedTickValues: import('vue').ComputedRef<any[]>;
+    computedMarks: import('vue').ComputedRef<{
+        text: any;
+        pct: any;
+        edge: string | null;
+    }[]>;
+    reservesAnnotationSpace: import('vue').ComputedRef<boolean>;
+};
+//# sourceMappingURL=UseSliderMarksAndTicks.d.ts.map

package/dist/components/Slider/Composables/UseSliderMarksAndTicks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UseSliderMarksAndTicks.d.ts","sourceRoot":"","sources":["../../../../components/Slider/Composables/UseSliderMarksAndTicks.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;EAgDC"}

package/dist/components/Slider/Composables/UseSliderTooltipReadout.d.ts

@@ -0,0 +1,10 @@
+export function useSliderTooltipReadout(props: any, { thumbVisualRefs, tooltipElRefs, isVertical, isRtl, readoutVisibility, formattedValues, onPosition, }: {
+    thumbVisualRefs: any;
+    tooltipElRefs: any;
+    isVertical: any;
+    isRtl: any;
+    readoutVisibility: any;
+    formattedValues: any;
+    onPosition: any;
+}): void;
+//# sourceMappingURL=UseSliderTooltipReadout.d.ts.map

package/dist/components/Slider/Composables/UseSliderTooltipReadout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UseSliderTooltipReadout.d.ts","sourceRoot":"","sources":["../../../../components/Slider/Composables/UseSliderTooltipReadout.js"],"names":[],"mappings":"AA6BA;;;;;;;;SAgKC"}

package/dist/components/Slider/Composables/UseSliderValue.d.ts

@@ -0,0 +1,16 @@
+export function useSliderValue(props: any, emit: any, { isRange, activeSnapValue }: {
+    isRange: any;
+    activeSnapValue: any;
+}): {
+    internalValues: import('vue').Ref<any, any>;
+    lastCommittedValues: import('vue').Ref<any[], any[]>;
+    currentValue: import('vue').ComputedRef<any>;
+    decimalPlaces: (n: any) => number;
+    snapToStep: (val: any) => number;
+    thumbPercent: (val: any) => number;
+    thumbNativeMin: (i: any) => any;
+    thumbNativeMax: (i: any) => any;
+    thumbNativeStep: (i: any) => any;
+    formatValue: (value: any, index: any) => string;
+};
+//# sourceMappingURL=UseSliderValue.d.ts.map

package/dist/components/Slider/Composables/UseSliderValue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UseSliderValue.d.ts","sourceRoot":"","sources":["../../../../components/Slider/Composables/UseSliderValue.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;EAkWC"}

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

@@ -0,0 +1,304 @@
+declare function focus(): void;
+declare function blur(): void;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        label?(_: any): any;
+        start?(_: {}): any;
+        end?(_: {}): any;
+    };
+    refs: {
+        controlRef: HTMLDivElement;
+        markElRefs: HTMLDivElement[];
+        readoutElRefs: HTMLDivElement[];
+        mergedReadoutElRef: HTMLDivElement;
+    };
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    modelValue: {
+        type: (ArrayConstructor | NumberConstructor)[];
+        default: undefined;
+        validator: (value: unknown) => boolean;
+    };
+    min: {
+        type: NumberConstructor;
+        default: number;
+        validator: (number: unknown) => boolean;
+    };
+    max: {
+        type: NumberConstructor;
+        default: number;
+        validator: (number: unknown) => boolean;
+    };
+    step: {
+        type: NumberConstructor;
+        default: number;
+        validator: (number: unknown) => boolean;
+    };
+    snapPoints: {
+        type: (ArrayConstructor | NumberConstructor)[];
+        default: undefined;
+        validator: (value: unknown) => boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    orientation: {
+        type: StringConstructor;
+        default: string;
+        validator: (v: unknown) => boolean;
+    };
+    fillOrigin: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: string;
+        validator: (v: unknown) => boolean;
+    };
+    showTicks: {
+        type: (NumberConstructor | BooleanConstructor)[];
+        default: boolean;
+    };
+    minGapSteps: {
+        type: NumberConstructor;
+        default: number;
+    };
+    label: {
+        type: StringConstructor;
+        default: string;
+    };
+    showLabel: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    labelSize: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: null;
+        validator: (s: unknown) => boolean;
+    };
+    labelStrength: {
+        type: StringConstructor;
+        default: null;
+        validator: (s: unknown) => boolean;
+    };
+    getValueText: {
+        type: FunctionConstructor;
+        default: null;
+    };
+    prefix: {
+        type: StringConstructor;
+        default: string;
+    };
+    suffix: {
+        type: StringConstructor;
+        default: string;
+    };
+    name: {
+        type: StringConstructor;
+        default: string;
+    };
+    largeStep: {
+        type: NumberConstructor;
+        default: number;
+    };
+    bodyClass: {
+        type: (ObjectConstructor | ArrayConstructor | StringConstructor)[];
+        default: string;
+    };
+    labelClass: {
+        type: (ObjectConstructor | ArrayConstructor | StringConstructor)[];
+        default: string;
+    };
+    startClass: {
+        type: (ObjectConstructor | ArrayConstructor | StringConstructor)[];
+        default: string;
+    };
+    endClass: {
+        type: (ObjectConstructor | ArrayConstructor | StringConstructor)[];
+        default: string;
+    };
+    readout: {
+        type: StringConstructor;
+        default: string;
+        validator: (v: unknown) => boolean;
+    };
+    readoutClass: {
+        type: (ObjectConstructor | ArrayConstructor | StringConstructor)[];
+        default: string;
+    };
+    showMarks: {
+        type: (ArrayConstructor | BooleanConstructor)[];
+        default: boolean;
+        validator: (value: unknown) => boolean;
+    };
+}>, {
+    focus: typeof focus;
+    blur: typeof blur;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    blur: (...args: any[]) => void;
+    change: (...args: any[]) => void;
+    focus: (...args: any[]) => void;
+    "update:modelValue": (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    modelValue: {
+        type: (ArrayConstructor | NumberConstructor)[];
+        default: undefined;
+        validator: (value: unknown) => boolean;
+    };
+    min: {
+        type: NumberConstructor;
+        default: number;
+        validator: (number: unknown) => boolean;
+    };
+    max: {
+        type: NumberConstructor;
+        default: number;
+        validator: (number: unknown) => boolean;
+    };
+    step: {
+        type: NumberConstructor;
+        default: number;
+        validator: (number: unknown) => boolean;
+    };
+    snapPoints: {
+        type: (ArrayConstructor | NumberConstructor)[];
+        default: undefined;
+        validator: (value: unknown) => boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    orientation: {
+        type: StringConstructor;
+        default: string;
+        validator: (v: unknown) => boolean;
+    };
+    fillOrigin: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: string;
+        validator: (v: unknown) => boolean;
+    };
+    showTicks: {
+        type: (NumberConstructor | BooleanConstructor)[];
+        default: boolean;
+    };
+    minGapSteps: {
+        type: NumberConstructor;
+        default: number;
+    };
+    label: {
+        type: StringConstructor;
+        default: string;
+    };
+    showLabel: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    labelSize: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: null;
+        validator: (s: unknown) => boolean;
+    };
+    labelStrength: {
+        type: StringConstructor;
+        default: null;
+        validator: (s: unknown) => boolean;
+    };
+    getValueText: {
+        type: FunctionConstructor;
+        default: null;
+    };
+    prefix: {
+        type: StringConstructor;
+        default: string;
+    };
+    suffix: {
+        type: StringConstructor;
+        default: string;
+    };
+    name: {
+        type: StringConstructor;
+        default: string;
+    };
+    largeStep: {
+        type: NumberConstructor;
+        default: number;
+    };
+    bodyClass: {
+        type: (ObjectConstructor | ArrayConstructor | StringConstructor)[];
+        default: string;
+    };
+    labelClass: {
+        type: (ObjectConstructor | ArrayConstructor | StringConstructor)[];
+        default: string;
+    };
+    startClass: {
+        type: (ObjectConstructor | ArrayConstructor | StringConstructor)[];
+        default: string;
+    };
+    endClass: {
+        type: (ObjectConstructor | ArrayConstructor | StringConstructor)[];
+        default: string;
+    };
+    readout: {
+        type: StringConstructor;
+        default: string;
+        validator: (v: unknown) => boolean;
+    };
+    readoutClass: {
+        type: (ObjectConstructor | ArrayConstructor | StringConstructor)[];
+        default: string;
+    };
+    showMarks: {
+        type: (ArrayConstructor | BooleanConstructor)[];
+        default: boolean;
+        validator: (value: unknown) => boolean;
+    };
+}>> & Readonly<{
+    onBlur?: ((...args: any[]) => any) | undefined;
+    onChange?: ((...args: any[]) => any) | undefined;
+    onFocus?: ((...args: any[]) => any) | undefined;
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+}>, {
+    label: string;
+    disabled: boolean;
+    modelValue: number | unknown[];
+    name: string;
+    labelClass: string | unknown[] | Record<string, any>;
+    showLabel: boolean;
+    labelSize: string | number;
+    labelStrength: string;
+    startClass: string | unknown[] | Record<string, any>;
+    endClass: string | unknown[] | Record<string, any>;
+    orientation: string;
+    bodyClass: string | unknown[] | Record<string, any>;
+    snapPoints: number | unknown[];
+    min: number;
+    max: number;
+    step: number;
+    fillOrigin: string | number;
+    showTicks: number | boolean;
+    minGapSteps: number;
+    getValueText: Function;
+    prefix: string;
+    suffix: string;
+    largeStep: number;
+    readout: string;
+    readoutClass: string | unknown[] | Record<string, any>;
+    showMarks: boolean | unknown[];
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    controlRef: HTMLDivElement;
+    markElRefs: HTMLDivElement[];
+    readoutElRefs: HTMLDivElement[];
+    mergedReadoutElRef: 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;
+    };
+};
+//# sourceMappingURL=Slider.vue.d.ts.map

package/dist/components/Slider/Slider.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Slider.vue.d.ts","sourceRoot":"","sources":["../../../components/Slider/Slider.vue"],"names":[],"mappings":"AA8NA;AAqzCA,iBAAS,KAAK,SAEb;AAED,iBAAS,IAAI,SAKZ;AAOD,iBAAS,cAAc;WA0PT,OAAO,IAA6B;;wBAhBvB,GAAG;uBACH,GAAG;qBACL,GAAG;;;;;;;;;EAmB3B;AA4VD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA0SnB,CAAC;wBACkB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;AAAnG,wBAAoG;AAEpG,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IACxC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KAEV,CAAA;CACD,CAAC"}

package/dist/components/Slider/SliderConstants.d.ts

@@ -0,0 +1,7 @@
+export declare const SLIDER_ORIENTATIONS: readonly ["horizontal", "vertical"];
+export declare const SLIDER_READOUT_MODES: readonly ["always", "never", "tooltip"];
+export declare const SLIDER_FILL_ORIGINS: readonly ["start", "end"];
+export declare const SLIDER_DEFAULT_LARGE_STEP = 10;
+export declare const SLIDER_EDGE_CLAMP_TOLERANCE_PX = 32;
+export declare const SLIDER_READOUT_EDGE_CLAMP_TOLERANCE_PX = 0;
+//# sourceMappingURL=SliderConstants.d.ts.map

package/dist/components/Slider/SliderConstants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SliderConstants.d.ts","sourceRoot":"","sources":["../../../components/Slider/SliderConstants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,mBAAmB,qCAAsC,CAAC;AAEvE,eAAO,MAAM,oBAAoB,yCAA0C,CAAC;AAE5E,eAAO,MAAM,mBAAmB,2BAA4B,CAAC;AAE7D,eAAO,MAAM,yBAAyB,KAAK,CAAC;AAK5C,eAAO,MAAM,8BAA8B,KAAK,CAAC;AAWjD,eAAO,MAAM,sCAAsC,IAAI,CAAC"}

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

@@ -0,0 +1,3 @@
+export { default as DtSlider } from './Slider.vue';
+export * from './SliderConstants';
+//# sourceMappingURL=index.d.ts.map

package/dist/components/Slider/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../components/Slider/index.js"],"names":[],"mappings":""}

package/dist/components/Slider/utils.d.ts

@@ -0,0 +1,8 @@
+export function isValidMark(mark: any): boolean;
+export function generateInterval(min: any, max: any, interval: any, label: any): any[];
+export function sameValues(a: any, b: any): any;
+export function edgeClampOffset(leftEdge: any, rightEdge: any, controlRect: any, tolerance: any): number;
+export function mirrorPct(pct: any, isRtl: any): any;
+export function measureEdgeInsetPx(controlEl: any): number;
+export const MAX_GENERATED_POINTS: 1000;
+//# sourceMappingURL=utils.d.ts.map

package/dist/components/Slider/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../components/Slider/utils.js"],"names":[],"mappings":"AAMA,gDAEC;AAKD,uFAgCC;AAGD,gDAEC;AAID,yGAMC;AAKD,qDAEC;AAYD,2DAWC;AAtFD,mCAAoC,IAAI,CAAC"}