@dxtmisha/d1 0.1.5 → 0.2.0

package/dist/D1Accordion.d.ts

@@ -0,0 +1,200 @@
+import { AccordionPropsBasic } from '@dxtmisha/constructor/Accordion';
+import { AccordionSlots } from '@dxtmisha/constructor/Accordion';
+import { CellPropsBasic } from '@dxtmisha/constructor/Cell';
+import { ComponentOptionsMixin } from 'vue';
+import { ComponentProvideOptions } from 'vue';
+import { ComputedRef } from 'vue';
+import { ConstrBind } from '@dxtmisha/functional';
+import { DefineComponent } from 'vue';
+import { EventClickValue } from '@dxtmisha/constructor';
+import { IconPropsBasic } from '@dxtmisha/constructor/Icon';
+import { ImagePropsBasic } from '@dxtmisha/constructor/Image';
+import { MotionTransformEmitOptions } from '@dxtmisha/constructor/MotionTransform';
+import { MotionTransformExpose } from '@dxtmisha/constructor/MotionTransform';
+import { MotionTransformPropsBasic } from '@dxtmisha/constructor/MotionTransform';
+import { ProgressPropsBasic } from '@dxtmisha/constructor/Progress';
+import { PublicProps } from 'vue';
+import { Ref } from 'vue';
+
+declare const __VLS_component: DefineComponent<D1AccordionProps, {
+    motionTransformElement: Ref< ConstrBind<MotionTransformExpose> | undefined>;
+    open: Ref<boolean>;
+    isShow: ComputedRef<boolean>;
+    setOpen(open: boolean): void;
+    toOpen(): void;
+    toClose(): void;
+    toggle(): void;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    click: (event: MouseEvent, value: EventClickValue) => any;
+    clickLite: (value: EventClickValue) => any;
+    transform: (event: Event | undefined, options: MotionTransformEmitOptions) => any;
+    transformLite: (options: MotionTransformEmitOptions) => any;
+    "update:open": (value: boolean) => any;
+    "update:modelOpen": (value: boolean) => any;
+}, string, PublicProps, Readonly<D1AccordionProps> & Readonly<{
+    onClick?: ((event: MouseEvent, value: EventClickValue) => any) | undefined;
+    onClickLite?: ((value: EventClickValue) => any) | undefined;
+    onTransform?: ((event: Event | undefined, options: MotionTransformEmitOptions) => any) | undefined;
+    onTransformLite?: ((options: MotionTransformEmitOptions) => any) | undefined;
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+    "onUpdate:modelOpen"?: ((value: boolean) => any) | undefined;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<AccordionSlots> & AccordionSlots;
+    refs: {};
+    rootEl: any;
+};
+
+declare type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+
+declare type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+/**
+ * Type describing incoming properties/ Тип, описывающий входящие свойства
+ */
+declare type CellProps = CellPropsBasic<IconProps, ProgressProps> & PropsToken_4;
+
+export declare const D1Accordion: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+
+/**
+ * Type describing incoming properties/ Тип, описывающий входящие свойства
+ */
+export declare type D1AccordionProps = AccordionPropsBasic<IconProps, CellProps, MotionTransformProps> & PropsToken_6;
+
+/**
+ * Type describing incoming properties/ Тип, описывающий входящие свойства
+ */
+declare type IconProps = IconPropsBasic<ImageProps> & PropsToken_2;
+
+/**
+ * Type describing incoming properties/ Тип, описывающий входящие свойства
+ */
+declare type ImageProps = ImagePropsBasic & PropsToken;
+
+/**
+ * Type describing incoming properties/ Тип, описывающий входящие свойства
+ */
+declare type MotionTransformProps = MotionTransformPropsBasic & PropsToken_5;
+
+/**
+ * Type describing incoming properties/ Тип, описывающий входящие свойства
+ */
+declare type ProgressProps = ProgressPropsBasic & PropsToken_3;
+
+declare type PropsToken = {
+    turn?: boolean;
+    disabled?: boolean;
+    hide?: boolean;
+    adaptive?: boolean;
+    size?: 'auto' | 'contain' | 'cover';
+};
+
+declare type PropsToken_2 = {
+    turn?: boolean;
+    disabled?: boolean;
+    hide?: boolean;
+    asPalette?: boolean;
+    dir?: boolean;
+    overlay?: boolean;
+    dynamic?: boolean;
+    start?: boolean;
+    end?: boolean;
+    high?: boolean;
+    animationType?: 'type1' | 'type2';
+    animationShow?: boolean;
+    square?: boolean;
+    circle?: boolean;
+    rect?: boolean;
+    size?: 'auto' | 'x' | 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl' | '3xl' | '4xl' | '5xl' | '6xl' | '7xl' | '8xl' | '9xl';
+    inverse?: boolean;
+    rounded?: 'auto' | 'sm' | 'md' | 'lg' | 'xl' | 'full';
+};
+
+declare type PropsToken_3 = {
+    point?: boolean;
+    linear?: boolean;
+    circular?: boolean;
+    indeterminate?: 'type1' | 'type2' | 'type3';
+    position?: 'top' | 'bottom' | 'static';
+    dense?: boolean;
+    inverse?: boolean;
+    size?: 'sm' | 'md' | 'lg';
+    palette?: 'red' | 'orange' | 'amber' | 'yellow' | 'lime' | 'green' | 'emerald' | 'teal' | 'cyan' | 'sky' | 'blue' | 'indigo' | 'violet' | 'purple' | 'fuchsia' | 'pink' | 'rose' | 'slate' | 'gray' | 'zinc' | 'neutral' | 'stone' | 'black' | 'white';
+};
+
+declare type PropsToken_4 = {
+    focus?: boolean;
+    selected?: boolean;
+    readonly?: boolean;
+    disabled?: boolean;
+    dynamic?: boolean;
+    dynamicHover?: boolean;
+    divider?: boolean;
+    dividerLabel?: 'always' | 'none' | 'adaptiveSm' | 'adaptiveMd' | 'adaptiveLg' | 'adaptiveXl' | 'adaptive2xl' | 'containerSm' | 'containerMd' | 'containerLg' | 'containerXl' | 'container2xl';
+    iconTop?: boolean;
+    padding?: 'sm' | 'md' | 'lg' | 'ySm' | 'yMd' | 'yLg' | 'none';
+    paddingByIndent?: boolean;
+};
+
+declare type PropsToken_5 = {
+    section?: boolean;
+    animationHeadPosition?: 'top' | 'toBottom';
+    adaptive?: 'planeAlways' | 'planeSm' | 'planeMd' | 'planeLg' | 'planeXl' | 'plane2xl';
+};
+
+declare type PropsToken_6 = {
+    divider?: boolean;
+};
+
+export { }
+
+
+declare module '@vue/runtime-core' {
+    interface GlobalComponents {
+        D1Accordion: typeof D1Accordion;
+        D1ActionSheet: typeof D1ActionSheet;
+        D1Actions: typeof D1Actions;
+        D1Anchor: typeof D1Anchor;
+        D1Arrow: typeof D1Arrow;
+        D1Badge: typeof D1Badge;
+        D1Bars: typeof D1Bars;
+        D1Block: typeof D1Block;
+        D1Button: typeof D1Button;
+        D1Cell: typeof D1Cell;
+        D1Chip: typeof D1Chip;
+        D1ChipGroup: typeof D1ChipGroup;
+        D1Dialog: typeof D1Dialog;
+        D1Field: typeof D1Field;
+        D1FieldCounter: typeof D1FieldCounter;
+        D1FieldLabel: typeof D1FieldLabel;
+        D1FieldMessage: typeof D1FieldMessage;
+        D1Icon: typeof D1Icon;
+        D1Image: typeof D1Image;
+        D1Input: typeof D1Input;
+        D1List: typeof D1List;
+        D1ListGroup: typeof D1ListGroup;
+        D1ListItem: typeof D1ListItem;
+        D1ListMenu: typeof D1ListMenu;
+        D1Mask: typeof D1Mask;
+        D1Menu: typeof D1Menu;
+        D1Modal: typeof D1Modal;
+        D1MotionTransform: typeof D1MotionTransform;
+        D1Page: typeof D1Page;
+        D1Progress: typeof D1Progress;
+        D1Ripple: typeof D1Ripple;
+        D1Scrollbar: typeof D1Scrollbar;
+        D1Section: typeof D1Section;
+        D1Select: typeof D1Select;
+        D1SelectValue: typeof D1SelectValue;
+        D1Skeleton: typeof D1Skeleton;
+        D1TextareaAutosize: typeof D1TextareaAutosize;
+        D1Tooltip: typeof D1Tooltip;
+        D1Window: typeof D1Window;
+    }
+}

package/dist/D1Accordion.js

@@ -1,396 +1,4 @@
-import { defineComponent as c, computed as t, openBlock as m, createBlock as y, unref as u, mergeDefaults as g } from "vue";
-import { inArray as n } from "@dxtmisha/functional";
-import { defaultsAccordion as b, AccordionDesign as D } from "@dxtmisha/constructor/Accordion";
-import { defaultsCell as k, CellDesign as $ } from "@dxtmisha/constructor/Cell";
-import { defaultsIcon as h, IconDesign as w } from "@dxtmisha/constructor/Icon";
-import { D as L } from "./index-BHi6Xmck.js";
-import { defaultsProgress as P, ProgressDesign as z } from "@dxtmisha/constructor/Progress";
-import { defaultsRipple as I, RippleDesign as A } from "@dxtmisha/constructor/Ripple";
-import { defaultsMotionTransform as H, MotionTransformDesign as S } from "@dxtmisha/constructor/MotionTransform";
-const T = {
-  // :values [!] System label / Системная метка
-  animationType: ["type1", "type2"],
-  size: ["auto", "x", "xs", "sm", "md", "lg", "xl", "2xl", "3xl", "4xl", "5xl", "6xl", "7xl", "8xl", "9xl"],
-  rounded: ["auto", "sm", "md", "lg", "xl", "full"]
-  // :values [!] System label / Системная метка
-}, M = {
-  ...h,
-  // :default [!] System label / Системная метка
-  animationType: "type1",
-  square: !0,
-  size: "auto",
-  rounded: "auto"
-}, O = /* @__PURE__ */ c({
-  name: "D1Icon",
-  __name: "D1Icon",
-  props: /* @__PURE__ */ g({
-    isSkeleton: { type: Boolean },
-    ariaLabel: {},
-    active: { type: Boolean },
-    icon: {},
-    iconActive: {},
-    role: {},
-    turn: { type: Boolean },
-    disabled: { type: Boolean },
-    hide: { type: Boolean },
-    asPalette: { type: Boolean },
-    dir: { type: Boolean },
-    overlay: { type: Boolean },
-    dynamic: { type: Boolean },
-    start: { type: Boolean },
-    end: { type: Boolean },
-    high: { type: Boolean },
-    animationType: {},
-    animationShow: { type: Boolean },
-    square: { type: Boolean },
-    circle: { type: Boolean },
-    rect: { type: Boolean },
-    size: {},
-    inverse: { type: Boolean },
-    rounded: {}
-  }, M),
-  emits: ["load"],
-  setup(i, { expose: a, emit: s }) {
-    const d = s, e = i, r = t(() => ({
-      main: {
-        // :classes-values [!] System label / Системная метка
-        "d1-icon": !0,
-        "d1-icon--turn": e.turn,
-        "d1-icon--disabled": e.disabled,
-        "d1-icon--hide": e.hide,
-        "d1-icon--asPalette": e.asPalette,
-        "d1-icon--dir": e.dir,
-        "d1-icon--overlay": e.overlay,
-        "d1-icon--dynamic": e.dynamic,
-        "d1-icon--start": e.start,
-        "d1-icon--end": e.end,
-        "d1-icon--high": e.high,
-        [`d1-icon--animationType--${e.animationType}`]: n(T.animationType, e.animationType),
-        "d1-icon--animationShow": e.animationShow,
-        "d1-icon--square": e.square && !e.circle && !e.rect,
-        "d1-icon--circle": e.circle,
-        "d1-icon--rect": e.rect,
-        [`d1-icon--size--${e.size}`]: n(T.size, e.size),
-        "d1-icon--inverse": e.inverse,
-        [`d1-icon--rounded--${e.rounded}`]: n(T.rounded, e.rounded)
-        // :classes-values [!] System label / Системная метка
-      }
-    })), l = t(() => ({
-      // :styles-values [!] System label / Системная метка
-      // :styles-values [!] System label / Системная метка
-    })), o = new w(
-      "d1.icon",
-      e,
-      {
-        emits: d,
-        components: {
-          image: L
-        },
-        classes: r,
-        styles: l
-      }
-    ), p = o.render();
-    return a(o.expose()), (B, f) => (m(), y(u(p)));
-  }
-}), v = {
-  // :values [!] System label / Системная метка
-  indeterminate: ["type1", "type2", "type3"],
-  position: ["top", "bottom", "static"],
-  size: ["sm", "md", "lg"],
-  palette: ["red", "orange", "amber", "yellow", "lime", "green", "emerald", "teal", "cyan", "sky", "blue", "indigo", "violet", "purple", "fuchsia", "pink", "rose", "slate", "gray", "zinc", "neutral", "stone", "black", "white"]
-  // :values [!] System label / Системная метка
-}, C = {
-  ...P,
-  // :default [!] System label / Системная метка
-  linear: !0,
-  indeterminate: "type1",
-  position: "top",
-  size: "md"
-}, V = /* @__PURE__ */ c({
-  name: "D1Progress",
-  __name: "D1Progress",
-  props: /* @__PURE__ */ g({
-    ariaLabel: {},
-    ariaLive: {},
-    visible: { type: Boolean },
-    value: {},
-    max: {},
-    linear: { type: Boolean },
-    circular: { type: Boolean },
-    point: { type: Boolean },
-    delay: {},
-    delayHide: {},
-    indeterminate: {},
-    position: {},
-    dense: { type: Boolean },
-    inverse: { type: Boolean },
-    size: {},
-    palette: {}
-  }, C),
-  setup(i, { expose: a, emit: s }) {
-    const d = s, e = i, r = t(() => ({
-      main: {
-        // :classes-values [!] System label / Системная метка
-        "d1-progress": !0,
-        "d1-progress--point": e.point,
-        "d1-progress--linear": e.linear && !e.circular,
-        "d1-progress--circular": e.circular,
-        [`d1-progress--indeterminate--${e.indeterminate}`]: n(v.indeterminate, e.indeterminate),
-        [`d1-progress--position--${e.position}`]: n(v.position, e.position),
-        "d1-progress--dense": e.dense,
-        "d1-progress--inverse": e.inverse,
-        [`d1-progress--size--${e.size}`]: n(v.size, e.size),
-        [`d1-palette d1-palette--${e.palette}`]: n(v.palette, e.palette)
-        // :classes-values [!] System label / Системная метка
-      }
-    })), l = t(() => ({
-      // :styles-values [!] System label / Системная метка
-      // :styles-values [!] System label / Системная метка
-    })), o = new z(
-      "d1.progress",
-      e,
-      {
-        emits: d,
-        classes: r,
-        styles: l
-      }
-    ), p = o.render();
-    return a(o.expose()), (B, f) => (m(), y(u(p)));
-  }
-}), q = {
-  ...I
-}, F = /* @__PURE__ */ c({
-  name: "D1Ripple",
-  __name: "D1Ripple",
-  props: /* @__PURE__ */ g({
-    disabled: { type: Boolean }
-  }, q),
-  setup(i, { expose: a, emit: s }) {
-    const d = s, e = i, r = t(() => ({
-      main: {
-        // :classes-values [!] System label / Системная метка
-        "d1-ripple": !0
-        // :classes-values [!] System label / Системная метка
-      }
-    })), l = t(() => ({
-      // :styles-values [!] System label / Системная метка
-      // :styles-values [!] System label / Системная метка
-    })), o = new A(
-      "d1.ripple",
-      e,
-      {
-        emits: d,
-        classes: r,
-        styles: l
-      }
-    ), p = o.render();
-    return a(o.expose()), (B, f) => (m(), y(u(p)));
-  }
-}), _ = {
-  // :values [!] System label / Системная метка
-  dividerLabel: ["always", "none", "adaptiveSm", "adaptiveMd", "adaptiveLg", "adaptiveXl", "adaptive2xl", "containerSm", "containerMd", "containerLg", "containerXl", "container2xl"],
-  padding: ["sm", "md", "lg", "ySm", "yMd", "yLg", "none"]
-  // :values [!] System label / Системная метка
-}, R = {
-  ...k,
-  // :default [!] System label / Системная метка
-  divider: !0,
-  padding: "none",
-  paddingByIndent: !0
-}, U = /* @__PURE__ */ c({
-  name: "D1Cell",
-  __name: "D1Cell",
-  props: /* @__PURE__ */ g({
-    label: {},
-    labelId: {},
-    description: {},
-    caption: {},
-    readonly: { type: Boolean },
-    disabled: { type: Boolean },
-    icon: {},
-    selected: { type: Boolean },
-    iconTurn: { type: Boolean },
-    iconHide: { type: Boolean },
-    iconDir: { type: Boolean },
-    iconPalette: { type: Boolean },
-    iconAttrs: {},
-    iconTrailing: {},
-    iconTrailingTurnOnly: { type: Boolean },
-    iconTrailingDirOnly: { type: Boolean },
-    iconTrailingPalette: { type: Boolean },
-    loading: { type: [Boolean, Object] },
-    isSkeleton: { type: Boolean },
-    to: {},
-    value: {},
-    detail: {},
-    role: {},
-    tag: {},
-    divider: { type: Boolean },
-    dynamic: { type: Boolean },
-    focus: { type: Boolean },
-    dynamicHover: { type: Boolean },
-    dividerLabel: {},
-    iconTop: { type: Boolean },
-    padding: {},
-    paddingByIndent: { type: Boolean }
-  }, R),
-  emits: ["click", "clickLite"],
-  setup(i, { expose: a, emit: s }) {
-    const d = s, e = i, r = t(() => ({
-      main: {
-        // :classes-values [!] System label / Системная метка
-        "d1-cell": !0,
-        "d1-cell--focus": e.focus,
-        "d1-cell--selected": e.selected,
-        "d1-cell--readonly": e.readonly,
-        "d1-cell--disabled": e.disabled,
-        "d1-cell--dynamic": e.dynamic,
-        "d1-cell--dynamicHover": e.dynamicHover,
-        "d1-cell--divider": e.divider,
-        [`d1-cell--dividerLabel--${e.dividerLabel}`]: n(_.dividerLabel, e.dividerLabel),
-        "d1-cell--iconTop": e.iconTop,
-        [`d1-cell--padding--${e.padding}`]: n(_.padding, e.padding),
-        "d1-cell--paddingByIndent": e.paddingByIndent
-        // :classes-values [!] System label / Системная метка
-      }
-    })), l = t(() => ({
-      // :styles-values [!] System label / Системная метка
-      // :styles-values [!] System label / Системная метка
-    })), o = new $(
-      "d1.cell",
-      e,
-      {
-        emits: d,
-        classes: r,
-        styles: l,
-        components: {
-          icon: O,
-          progress: V,
-          ripple: F
-        }
-      }
-    ), p = o.render();
-    return a(o.expose()), (B, f) => (m(), y(u(p)));
-  }
-}), X = U, x = {
-  // :values [!] System label / Системная метка
-  animationHeadPosition: ["top", "toBottom"],
-  adaptive: ["planeAlways", "planeSm", "planeMd", "planeLg", "planeXl", "plane2xl"]
-  // :values [!] System label / Системная метка
-}, j = {
-  ...H,
-  // :default [!] System label / Системная метка
-  animationHeadPosition: "top",
-  adaptive: "planeMd"
-}, E = /* @__PURE__ */ c({
-  name: "D1MotionTransform",
-  __name: "D1MotionTransform",
-  props: /* @__PURE__ */ g({
-    role: {},
-    ariaLabelledby: {},
-    ariaDescribedby: {},
-    open: { type: Boolean },
-    inDom: { type: Boolean },
-    ignore: {},
-    ignoreSelector: {},
-    clickOpen: { type: Boolean },
-    autoClose: { type: Boolean },
-    animationShow: { type: Boolean },
-    tagBody: {},
-    modelOpen: { type: Boolean },
-    "onUpdate:open": { type: Function },
-    "onUpdate:modelOpen": { type: Function },
-    section: { type: Boolean },
-    animationHeadPosition: {},
-    adaptive: {}
-  }, j),
-  emits: ["transform", "transformLite", "update:open", "update:modelOpen"],
-  setup(i, { expose: a, emit: s }) {
-    const d = s, e = i, r = t(() => ({
-      main: {
-        // :classes-values [!] System label / Системная метка
-        "d1-motionTransform": !0,
-        "d1-motionTransform--section": e.section,
-        [`d1-motionTransform--animationHeadPosition--${e.animationHeadPosition}`]: n(x.animationHeadPosition, e.animationHeadPosition),
-        [`d1-motionTransform--adaptive--${e.adaptive}`]: n(x.adaptive, e.adaptive)
-        // :classes-values [!] System label / Системная метка
-      }
-    })), l = t(() => ({
-      // :styles-values [!] System label / Системная метка
-      // :styles-values [!] System label / Системная метка
-    })), o = new S(
-      "d1.motionTransform",
-      e,
-      {
-        emits: d,
-        classes: r,
-        styles: l
-      }
-    ), p = o.render();
-    return a(o.expose()), (B, f) => (m(), y(u(p)));
-  }
-}), G = E, J = {
-  // :values [!] System label / Системная метка
-  padding: ["sm", "md", "lg", "ySm", "yMd", "yLg", "none"]
-  // :values [!] System label / Системная метка
-}, K = {
-  ...b,
-  iconArrowDown: "keyboard_arrow_down",
-  // :default [!] System label / Системная метка
-  divider: !0,
-  padding: "none",
-  paddingByIndent: !0
-}, ie = /* @__PURE__ */ c({
-  name: "D1Accordion",
-  __name: "D1Accordion",
-  props: /* @__PURE__ */ g({
-    label: {},
-    labelId: {},
-    description: {},
-    icon: {},
-    open: { type: Boolean },
-    clickOpen: { type: Boolean },
-    autoClose: { type: Boolean },
-    motionTransformAttrs: {},
-    cellAttrs: {},
-    iconArrowDown: {},
-    modelOpen: { type: Boolean },
-    "onUpdate:open": { type: Function },
-    "onUpdate:modelOpen": { type: Function },
-    divider: { type: Boolean },
-    padding: {},
-    paddingByIndent: { type: Boolean }
-  }, K),
-  emits: ["click", "clickLite", "transform", "transformLite", "update:open", "update:modelOpen"],
-  setup(i, { expose: a, emit: s }) {
-    const d = s, e = i, r = t(() => ({
-      main: {
-        // :classes-values [!] System label / Системная метка
-        "d1-accordion": !0,
-        "d1-accordion--divider": e.divider,
-        [`d1-accordion--padding--${e.padding}`]: n(J.padding, e.padding),
-        "d1-accordion--paddingByIndent": e.paddingByIndent
-        // :classes-values [!] System label / Системная метка
-      }
-    })), l = t(() => ({
-      // :styles-values [!] System label / Системная метка
-      // :styles-values [!] System label / Системная метка
-    })), o = new D(
-      "d1.accordion",
-      e,
-      {
-        emits: d,
-        classes: r,
-        styles: l,
-        components: {
-          cell: X,
-          motionTransform: G
-        }
-      }
-    ), p = o.render();
-    return a(o.expose()), (B, f) => (m(), y(u(p)));
-  }
-});
+import { _ as c } from "./D1Accordion.vue_vue_type_script_setup_true_lang-ZmnMZM7M.js";
 export {
-  ie as D1Accordion
+  c as D1Accordion
 };

package/dist/D1Accordion.vue_vue_type_script_setup_true_lang-ZmnMZM7M.js

@@ -0,0 +1,61 @@
+import { defineComponent as p, computed as n, openBlock as l, createBlock as m, unref as f, mergeDefaults as u } from "vue";
+import "@dxtmisha/functional";
+import { defaultsAccordion as _, AccordionDesign as y } from "@dxtmisha/constructor/Accordion";
+import { _ as D } from "./D1Cell.vue_vue_type_script_setup_true_lang-DUsqN8j7.js";
+import { D as k } from "./index-D387qGGl.js";
+const A = D, w = {
+  ..._,
+  iconArrowDown: "keyboard_arrow_down",
+  // :default [!] System label / Системная метка
+  divider: !0
+}, C = /* @__PURE__ */ p({
+  name: "D1Accordion",
+  __name: "D1Accordion",
+  props: /* @__PURE__ */ u({
+    label: {},
+    labelId: {},
+    description: {},
+    descriptionId: {},
+    icon: {},
+    open: { type: Boolean },
+    clickOpen: { type: Boolean },
+    autoClose: { type: Boolean },
+    motionTransformAttrs: {},
+    cellAttrs: {},
+    iconArrowDown: {},
+    modelOpen: { type: Boolean },
+    "onUpdate:open": { type: Function },
+    "onUpdate:modelOpen": { type: Function },
+    divider: { type: Boolean }
+  }, w),
+  emits: ["click", "clickLite", "transform", "transformLite", "update:open", "update:modelOpen"],
+  setup(t, { expose: r, emit: c }) {
+    const s = c, o = t, i = n(() => ({
+      main: {
+        // :classes-values [!] System label / Системная метка
+        "d1-accordion": !0,
+        "d1-accordion--divider": o.divider
+        // :classes-values [!] System label / Системная метка
+      }
+    })), d = n(() => ({
+      // :styles-values [!] System label / Системная метка
+      // :styles-values [!] System label / Системная метка
+    })), e = new y(
+      "d1.accordion",
+      o,
+      {
+        emits: s,
+        classes: i,
+        styles: d,
+        components: {
+          cell: A,
+          motionTransform: k
+        }
+      }
+    ), a = e.render();
+    return r(e.expose()), (B, T) => (l(), m(f(a)));
+  }
+});
+export {
+  C as _
+};