@pantograph/vue 0.23.3 → 0.23.5

package/dist/{ColorTrigger.vue_vue_type_style_index_0_lang-BNTg203W.js → ColorTrigger.vue_vue_type_style_index_0_lang-W0kl7vow.js}

@@ -1,11 +1,13 @@
-import { defineComponent as C, computed as c, useSlots as I, createElementBlock as S, openBlock as l, unref as r, normalizeClass as v, createVNode as _, createBlock as k, createCommentVNode as h, normalizeProps as f, guardReactiveProps as m, createSlots as y, renderList as w, withCtx as u, renderSlot as d } from "vue";
-import { _ as O } from "./GraphicalObject.vue_vue_type_script_setup_true_lang-BZCn44kG.js";
+import { defineComponent as C, computed as c, useSlots as I, createElementBlock as S, openBlock as l, unref as r, normalizeClass as _, createVNode as v, createBlock as k, createCommentVNode as h, normalizeProps as m, guardReactiveProps as f, createSlots as y, renderList as w, withCtx as u, renderSlot as d } from "vue";
+import { _ as O } from "./GraphicalObject.vue_vue_type_script_setup_true_lang-tkL7jO-r.js";
 import { g as $ } from "./options-D4et5euX.js";
-import { getBemBlock as T, generateVariantClassList as t } from "@pantograph/utils";
+import { getBemBlock as T, generateVariantClassList as n } from "@pantograph/utils";
 import { cva as V } from "class-variance-authority";
-import { j, f as G, g as L } from "./Icon.vue_vue_type_style_index_0_lang-Kn_r4tp8.js";
-import { u as N } from "./useInputDataStates-BVOCxFWp.js";
-const g = ["sm", "md", "lg"], P = ["disabled"], K = /* @__PURE__ */ C({
+import { _ as G } from "./Icon.vue_vue_type_style_index_0_lang-CbLL-Ngi.js";
+import { a as L } from "./index-jwkhq8oW.js";
+import { f as N } from "./FormItem.vue_vue_type_style_index_0_lang-DbMENNc4.js";
+import { u as P } from "./useInputDataStates-Bzs7T9xb.js";
+const g = ["sm", "md", "lg"], j = ["disabled"], Q = /* @__PURE__ */ C({
   ...$("ColorTrigger"),
   __name: "ColorTrigger",
   props: {
@@ -22,15 +24,15 @@ const g = ["sm", "md", "lg"], P = ["disabled"], K = /* @__PURE__ */ C({
   setup(p) {
     const s = p, o = T("color_trigger"), z = V(o, {
       variants: {
-        size: t(g, o),
-        borderless: t("borderless", o),
-        suffixIcon: t("suffix-icon", o)
+        size: n(g, o),
+        borderless: n("borderless", o),
+        suffixIcon: n("suffix-icon", o)
       }
-    }), { getDisabled: b, getSize: n } = N({
+    }), { getDisabled: b, getSize: i } = P({
       getSize: () => s.size && g.includes(s.size) ? s.size : "md"
     }), x = c(() => ({
       size: (() => {
-        switch (n.value) {
+        switch (i.value) {
           case "sm":
             return "2xsm";
           case "md":
@@ -39,9 +41,9 @@ const g = ["sm", "md", "lg"], P = ["disabled"], K = /* @__PURE__ */ C({
             return "sm";
         }
       })(),
-      ...j(s, "icon", "bg", "br", "fg")
-    })), i = I(), B = c(() => {
-      switch (n.value) {
+      ...N(s, "icon", "bg", "br", "fg")
+    })), t = I(), B = c(() => {
+      switch (i.value) {
         case "sm":
           return "2xsm";
         case "md":
@@ -50,25 +52,25 @@ const g = ["sm", "md", "lg"], P = ["disabled"], K = /* @__PURE__ */ C({
       }
     });
     return (e, D) => (l(), S("button", {
-      class: v([
+      class: _([
         r(z)({
-          size: r(n),
+          size: r(i),
           borderless: e.borderless,
-          suffixIcon: !!(e.suffixIcon || i.suffixIcon)
+          suffixIcon: !!(e.suffixIcon || t.suffixIcon)
         }),
         s.class
       ]),
       disabled: r(b)
     }, [
-      _(O, f(m(x.value)), y({ _: 2 }, [
-        w(Object.keys(i), (a) => ({
+      v(O, m(f(x.value)), y({ _: 2 }, [
+        w(Object.keys(t), (a) => ({
           name: a,
           fn: u(() => [
-            d(e.$slots, a, f(m(s)))
+            d(e.$slots, a, m(f(s)))
           ])
         }))
       ]), 1040),
-      e.suffixIcon || i.suffixIcon ? (l(), k(G, {
+      e.suffixIcon || t.suffixIcon ? (l(), k(G, {
         key: 0,
         icon: r(L)(e.suffixIcon) ? e.suffixIcon : void 0,
         size: B.value
@@ -78,10 +80,10 @@ const g = ["sm", "md", "lg"], P = ["disabled"], K = /* @__PURE__ */ C({
         ]),
         _: 3
       }, 8, ["icon", "size"])) : h("", !0)
-    ], 10, P));
+    ], 10, j));
   }
 });
 export {
   g as C,
-  K as _
+  Q as _
 };

package/dist/Combobox/Combobox.d.ts

@@ -0,0 +1,82 @@
+import { ComboboxProps, ComboboxSlots } from './types';
+declare function __VLS_template(): {
+    slots: Readonly<ComboboxSlots> & ComboboxSlots;
+    refs: {};
+    attrs: Partial<{}>;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<ComboboxProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: import('reka-ui', { with: { "resolution-mode": "import" } }).AcceptableValue) => any;
+    "update:open": (value: boolean) => any;
+    escapeKeyDown: (event: KeyboardEvent) => any;
+    pointerDownOutside: (event: CustomEvent<{
+        originalEvent: PointerEvent;
+    }>) => any;
+    focusOutside: (event: CustomEvent<{
+        originalEvent: FocusEvent;
+    }>) => any;
+    interactOutside: (event: CustomEvent<{
+        originalEvent: PointerEvent;
+    }> | CustomEvent<{
+        originalEvent: FocusEvent;
+    }>) => any;
+    "update:search": () => any;
+    highlight: (payload: {
+        ref: HTMLElement;
+        value: import('reka-ui', { with: { "resolution-mode": "import" } }).AcceptableValue;
+    } | undefined) => any;
+}, string, import('vue').PublicProps, Readonly<ComboboxProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: import('reka-ui', { with: { "resolution-mode": "import" } }).AcceptableValue) => any) | undefined;
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+    onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
+    onPointerDownOutside?: ((event: CustomEvent<{
+        originalEvent: PointerEvent;
+    }>) => any) | undefined;
+    onFocusOutside?: ((event: CustomEvent<{
+        originalEvent: FocusEvent;
+    }>) => any) | undefined;
+    onInteractOutside?: ((event: CustomEvent<{
+        originalEvent: PointerEvent;
+    }> | CustomEvent<{
+        originalEvent: FocusEvent;
+    }>) => any) | undefined;
+    "onUpdate:search"?: (() => any) | undefined;
+    onHighlight?: ((payload: {
+        ref: HTMLElement;
+        value: import('reka-ui', { with: { "resolution-mode": "import" } }).AcceptableValue;
+    } | undefined) => any) | undefined;
+}>, {
+    size: import('./Combobox.model.ts', { with: { "resolution-mode": "import" } }).ComboboxSize;
+    disabled: boolean;
+    placement: import('../index.ts', { with: { "resolution-mode": "import" } }).PopoverPlacement;
+    forceMount: boolean;
+    prioritizePosition: boolean;
+    sideOffset: number;
+    avoidCollisions: boolean;
+    collisionPadding: number | Partial<Record<"top" | "bottom" | "right" | "left", number>>;
+    disableUpdateOnLayoutShift: boolean;
+    hideWhenDetached: boolean;
+    positionStrategy: "absolute" | "fixed";
+    defaultOpen: boolean;
+    open: boolean;
+    trailingIcon: string;
+    bordered: boolean;
+    multiple: boolean;
+    resetSearchTermOnBlur: boolean;
+    resetSearchTermOnSelect: boolean;
+    tagRenderMode: "chip" | "avatar" | "go";
+    selectedItemIconAsTrailingIcon: boolean;
+    indicatorIcon: string;
+    loadingRowCount: number;
+    clearOnChangeMultiple: boolean;
+    samePopupWidth: boolean;
+    popupHeight: string | number;
+    position: "inline" | "popper";
+}, {}, {}, {}, 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/Combobox/Combobox.model.d.ts

@@ -0,0 +1,4 @@
+export declare const ComboboxSizes: readonly ["sm", "md", "lg"];
+export type ComboboxSize = (typeof ComboboxSizes)[number];
+export declare const ComboboxStatuses: readonly ["error", "warning", "success"];
+export type ComboboxStatus = (typeof ComboboxStatuses)[number];

package/dist/Combobox/ComboboxInput.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/Combobox/ComboboxLabel.d.ts

@@ -0,0 +1,16 @@
+declare function __VLS_template(): {
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    attrs: Partial<{}>;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, 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/Combobox/ComboboxOption.d.ts

@@ -0,0 +1,19 @@
+import { SlotsType } from 'vue';
+import { ComboboxOptionType, ComboboxOptionSlots } from './types';
+export interface SelectOptionProps {
+    option: ComboboxOptionType;
+}
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    option: {
+        type: () => ComboboxOptionType;
+        required: true;
+    };
+}>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    option: {
+        type: () => ComboboxOptionType;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, SlotsType<ComboboxOptionSlots>, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/Combobox/ComboboxTrigger.d.ts

@@ -0,0 +1,4 @@
+declare const _default: import('vue').DefineComponent<{}, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/Combobox/ComboboxWrapper.d.ts

@@ -0,0 +1,4 @@
+declare const _default: import('vue').DefineComponent<{}, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>[], {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/Combobox/context.d.ts

@@ -0,0 +1,34 @@
+import { ComboboxEmitObject, ComboboxOptionType, ComboboxProps } from './types.js';
+import { injectComboboxRootContext } from 'reka-ui';
+import { ComputedRef, Ref } from 'vue';
+import { ComboboxSize, ComboboxStatus } from './Combobox.model';
+export type ComboboxRootContext = Exclude<ReturnType<typeof injectComboboxRootContext>, undefined | null>;
+export interface _ComboboxContext {
+    props: ComboboxProps;
+    attrs: Record<string, any>;
+    emitsAsProps: ComboboxEmitObject;
+    searchModel: Ref<string | undefined>;
+    emit: any;
+}
+export interface ComboboxContext extends Omit<ComboboxRootContext, 'modelValue'>, Omit<_ComboboxContext, 'emitsAsProps'> {
+    modelValue: Ref<string | string[] | undefined>;
+    getOptionValue: (option?: ComboboxOptionType) => string | undefined;
+    getOptionLabel: (option?: ComboboxOptionType) => string | undefined;
+    getOptionDisabled: (option?: ComboboxOptionType) => boolean | undefined;
+    getOptionIcon: (option?: ComboboxOptionType) => string | undefined;
+    getOptionDescription: (option?: ComboboxOptionType) => string | undefined;
+    getOptionByValue: (value: string) => ComboboxOptionType | undefined;
+    getLabelByValue: (value: string) => string | undefined;
+    focusOnInput: () => void;
+    headerInputElement: Ref<HTMLElement | undefined>;
+    getDisabled: ComputedRef<boolean>;
+    getStatus: ComputedRef<ComboboxStatus>;
+    getSize: ComputedRef<ComboboxSize>;
+    setModelValue: (value: undefined | string | string[]) => void;
+    getTagSize: ComputedRef<'md' | 'xsm' | 'sm'>;
+    comboboxInputBinding: ComputedRef<object>;
+    comboboxTriggerBinding: ComputedRef<object>;
+}
+export declare const injectComboboxContext: <T extends ComboboxContext | null | undefined = ComboboxContext>(fallback?: T | undefined) => T extends null ? ComboboxContext | null : ComboboxContext, provideComboboxContext: (contextValue: ComboboxContext) => ComboboxContext;
+export declare const _injectComboboxContext: <T extends _ComboboxContext | null | undefined = _ComboboxContext>(fallback?: T | undefined) => T extends null ? _ComboboxContext | null : _ComboboxContext, __provideComboboxContext: (contextValue: _ComboboxContext) => _ComboboxContext;
+export declare const comboboxPrefix: string;

package/dist/Combobox/index.d.ts

@@ -0,0 +1,4 @@
+export { default as Combobox } from './Combobox';
+export { type ComboboxSize, type ComboboxStatus, ComboboxSizes, ComboboxStatuses, } from './Combobox.model';
+export type { ComboboxSlots, ComboboxProps, ComboboxEmits, ComboboxOptionType } from './types';
+export { provideComboboxContext, injectComboboxContext, type ComboboxContext } from './context';

package/dist/Combobox/index.js

@@ -0,0 +1,8 @@
+import { _ as s, C as t, a as x, i as C, p as a } from "../Combobox.vue_vue_type_style_index_0_lang-B2b5MoSC.js";
+export {
+  s as Combobox,
+  t as ComboboxSizes,
+  x as ComboboxStatuses,
+  C as injectComboboxContext,
+  a as provideComboboxContext
+};

package/dist/Combobox/index.umd.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const o=require("../Combobox.vue_vue_type_style_index_0_lang-DUnSgObq.js");exports.Combobox=o._sfc_main;exports.ComboboxSizes=o.ComboboxSizes;exports.ComboboxStatuses=o.ComboboxStatuses;exports.injectComboboxContext=o.injectComboboxContext;exports.provideComboboxContext=o.provideComboboxContext;

package/dist/Combobox/types.d.ts

@@ -0,0 +1,111 @@
+import { ComboboxRootEmits, ComboboxRootProps, ComboboxContentEmits, ComboboxContentProps, ComboboxPortalProps, ComboboxTriggerProps, ComboboxAnchorProps } from 'reka-ui';
+import { GetPopupContainer } from '../Popover/Popover';
+import { PopoverPlacement } from '../Popover';
+import { Direction } from '../ConfigProvider';
+import { SkeletonProps } from '../Skeleton/Skeleton';
+import { ComboboxSize, ComboboxStatus } from './Combobox.model';
+import { Class, EmitToProp } from '../types';
+import { ScrollContainerProps } from '../ScrollContainer/index.js';
+import { EmptyProps } from '../Empty/Empty';
+export type ComboboxOptionType = {
+    icon?: string;
+    label?: string;
+    value?: string;
+    description?: string;
+    disabled?: boolean;
+    options?: ComboboxOptionType[];
+} | object | string;
+export type ComboboxOptionGetter<T = string> = string | number | ((option: object) => T | undefined);
+export interface ComboboxProps extends Omit<ComboboxRootProps, 'ignoreFilter'>, Omit<ComboboxTriggerProps, 'as' | 'asChild'>, Omit<ComboboxAnchorProps, 'as' | 'asChild'>, ComboboxContentProps, Omit<ComboboxPortalProps, 'to'> {
+    size?: ComboboxSize;
+    status?: ComboboxStatus;
+    multiple?: boolean;
+    tagRenderMode?: 'chip' | 'avatar' | 'go';
+    getTagProps?: (option: ComboboxOptionType) => Record<string, any>;
+    tree?: boolean;
+    contentFit?: boolean;
+    wrapped?: boolean;
+    noTrailing?: boolean;
+    leadingIcon?: string;
+    trailingIcon?: string;
+    selectedItemIconAsTrailingIcon?: boolean;
+    maxCount?: number | string;
+    to?: string | HTMLElement | GetPopupContainer;
+    placeholder?: string;
+    indicatorIcon?: string;
+    options?: ComboboxOptionType[];
+    getDisabled?: ComboboxOptionGetter<boolean>;
+    getLabel?: ComboboxOptionGetter;
+    getDescription?: ComboboxOptionGetter;
+    getValue?: ComboboxOptionGetter;
+    getGroupOptions?: ComboboxOptionGetter<ComboboxOptionType[]>;
+    getGroupLabel?: ComboboxOptionGetter;
+    getIcon?: ComboboxOptionGetter;
+    placement?: PopoverPlacement;
+    reversePlacementOnDir?: Direction;
+    loading?: boolean;
+    skeletonProps?: SkeletonProps;
+    loadingRowCount?: number;
+    lazyLoading?: boolean;
+    bordered?: boolean;
+    clearOnChangeMultiple?: boolean;
+    triggerCls?: Class;
+    triggerLeadingCls?: Class;
+    triggerContentCls?: Class;
+    triggerContentPlaceholderCls?: Class;
+    triggerContentValueCls?: Class;
+    triggerTrailingCls?: Class;
+    itemLeadingCls?: Class;
+    optionCls?: Class;
+    tagCls?: Class;
+    popupCls?: Class;
+    labelCls?: Class;
+    optionsCls?: Class;
+    optionTextCls?: Class;
+    optionContentCls?: Class;
+    emptyCls?: Class;
+    skeletonCls?: Class;
+    scrollContainerProps?: ScrollContainerProps;
+    emptyProps?: EmptyProps;
+    samePopupWidth?: boolean;
+    popupHeight?: string | number;
+    popupWidth?: string | number;
+    minWidth?: string | number;
+    headerSearch?: boolean;
+    search?: string;
+}
+export interface ComboboxEmits extends ComboboxRootEmits, ComboboxContentEmits {
+    'update:search': (value?: string | null) => void;
+}
+export type ComboboxEmitObject = {
+    [K in keyof ComboboxEmits as EmitToProp<K>]: () => void;
+};
+export interface ComboboxOptionSlotProps {
+    option: ComboboxOptionType;
+}
+export interface ComboboxOptionSlots {
+    trailing?: (data: ComboboxOptionSlotProps) => never;
+}
+interface ComboboxTriggerDefSlotProps {
+    modelValue: string | string[] | undefined;
+    open: boolean;
+}
+export interface ComboboxTriggerSlots {
+    trigger?: (data: ComboboxTriggerDefSlotProps) => never;
+    triggerTrailing?: (data: ComboboxTriggerDefSlotProps) => never;
+}
+export interface ComboboxSlots extends ComboboxTriggerSlots {
+    empty?: (data?: object) => never;
+    loading?: (data?: object) => never;
+    header?: (data?: object) => never;
+    footer?: (data?: {
+        isEmpty: boolean;
+        search: string | undefined;
+    }) => never;
+    emptyTitle?: (data?: object) => never;
+    emptyDescription?: (data?: object) => never;
+    emptyActions?: (data?: object) => never;
+    emptyImage?: (data?: object) => never;
+    optionTrailing?: (data: ComboboxOptionSlotProps) => never;
+}
+export {};