@vueland/ui 0.0.1

package/dist/components/CApp/CApp.js

@@ -0,0 +1,46 @@
+import { defineComponent, provide, openBlock, createElementBlock, normalizeClass, unref, createElementVNode, renderSlot } from 'vue';
+import { useAppScroll } from '../../composables/use-app-scroll.js';
+import { $APP_API_KEY } from '../../constants/provide-keys.js';
+
+const _hoisted_1 = { class: "c-app__wrapper" };
+var _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{
+    name: "CApp"
+  },
+  __name: "CApp",
+  setup(__props) {
+    const {
+      appRef,
+      classes,
+      getScrollTop,
+      getScrollLeft,
+      blockScroll,
+      unblockScroll
+    } = useAppScroll();
+    provide($APP_API_KEY, {
+      getScrollTop,
+      getScrollLeft,
+      blockScroll,
+      unblockScroll
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock(
+        "div",
+        {
+          ref_key: "appRef",
+          ref: appRef,
+          class: normalizeClass(["c-app", unref(classes)])
+        },
+        [
+          createElementVNode("div", _hoisted_1, [
+            renderSlot(_ctx.$slots, "default")
+          ])
+        ],
+        2
+        /* CLASS */
+      );
+    };
+  }
+});
+
+export { _sfc_main as default };

package/dist/components/CApp/index.js

@@ -0,0 +1,5 @@
+import _sfc_main from './CApp.js';
+
+
+
+export { _sfc_main as default };

package/dist/components/CAutocomplete/CAutocomplete.js

@@ -0,0 +1,163 @@
+import { defineComponent, shallowRef, useModel, watch, unref, resolveComponent, openBlock, createBlock, mergeProps, createSlots, withCtx, createElementVNode, toDisplayString, createVNode, renderSlot, createTextVNode, isRef, toHandlers, renderList, normalizeProps, guardReactiveProps, mergeModels } from 'vue';
+import { useAutocomplete } from '../../composables/use-autocomplete.js';
+import _sfc_main$1 from '../CInput/CInput.js';
+import _sfc_main$2 from '../CMenu/CMenu.js';
+import { CItems } from '../CItems/CItems.js';
+import _sfc_main$3 from '../CField/CField.js';
+import { IconAliases } from '../../enums/IconName.js';
+
+var _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{
+    name: "CAutocomplete"
+  },
+  __name: "CAutocomplete",
+  props: /* @__PURE__ */ mergeModels({
+    modelValue: {},
+    items: {},
+    multiple: { type: Boolean },
+    options: {}
+  }, {
+    "modelValue": {},
+    "modelModifiers": {}
+  }),
+  emits: /* @__PURE__ */ mergeModels(["update:search"], ["update:modelValue"]),
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const { input, searchItems, rollbackValue } = useAutocomplete(props);
+    const inputRef = shallowRef();
+    const model = useModel(__props, "modelValue", {
+      get: () => props.modelValue,
+      set: (val) => val
+    });
+    function onCloseMenu() {
+      unref(inputRef).onBlur();
+    }
+    function onSelect(value) {
+      if (props.multiple) {
+        model.value = [...model.value, value];
+        return;
+      }
+      model.value = value;
+    }
+    watch(input, (val) => {
+      emit("update:search", unref(input));
+      if (!val) {
+        model.value = props.multiple ? [] : void 0;
+      }
+    });
+    return (_ctx, _cache) => {
+      const _component_c_icon = resolveComponent("c-icon");
+      return openBlock(), createBlock(unref(_sfc_main$1), mergeProps({
+        ref_key: "inputRef",
+        ref: inputRef,
+        modelValue: model.value,
+        "onUpdate:modelValue": _cache[2] || (_cache[2] = ($event) => model.value = $event)
+      }, _ctx.$attrs, { "validate-on": "blur" }), createSlots({
+        field: withCtx(({ onInput, onFocus, focused, presets, readonly, attrs, uid }) => {
+          var _a;
+          return [
+            createVNode(unref(_sfc_main$2), {
+              id: `${uid}-menu`,
+              bottom: "",
+              "open-on-focus": "",
+              "close-on-click-outside": "",
+              "close-on-content-click": !__props.multiple,
+              "offset-y": 2,
+              strategy: "reverse",
+              preset: (_a = __props.options) == null ? void 0 : _a.menuPreset,
+              onClose: onCloseMenu,
+              onOpen: unref(rollbackValue)
+            }, {
+              activator: withCtx(({ on, activator }) => [
+                createElementVNode(
+                  "div",
+                  mergeProps({ class: "c-autocomplete" }, activator, { class: presets }),
+                  [
+                    createVNode(unref(_sfc_main$3), mergeProps({
+                      id: uid,
+                      modelValue: unref(input),
+                      "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => isRef(input) ? input.value = $event : null),
+                      class: "c-autocomplete__field",
+                      type: "text",
+                      focused
+                    }, attrs, {
+                      readonly,
+                      "aria-controls": `${uid}-menu`,
+                      "aria-expanded": focused
+                    }, toHandlers(on), {
+                      onFocus,
+                      onInput
+                    }), null, 16, ["id", "modelValue", "focused", "readonly", "aria-controls", "aria-expanded", "onFocus", "onInput"])
+                  ],
+                  16
+                  /* FULL_PROPS */
+                )
+              ]),
+              default: withCtx(() => [
+                renderSlot(_ctx.$slots, "menu", {
+                  onSelect,
+                  items: unref(searchItems)
+                }, () => [
+                  createVNode(unref(CItems), {
+                    modelValue: model.value,
+                    "onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => model.value = $event),
+                    options: __props.options,
+                    items: unref(searchItems),
+                    multiple: __props.multiple,
+                    mandatory: ""
+                  }, {
+                    "no-items-message": withCtx(() => [
+                      renderSlot(_ctx.$slots, "no-items-message", {}, () => {
+                        var _a2, _b;
+                        return [
+                          createTextVNode(
+                            toDisplayString((_b = (_a2 = __props.options) == null ? void 0 : _a2.noItemsMessage) != null ? _b : "\u041D\u0435\u0442 \u0441\u043E\u0432\u043F\u0430\u0434\u0435\u043D\u0438\u0439"),
+                            1
+                            /* TEXT */
+                          )
+                        ];
+                      })
+                    ]),
+                    _: 3
+                    /* FORWARDED */
+                  }, 8, ["modelValue", "options", "items", "multiple"])
+                ])
+              ]),
+              _: 2
+              /* DYNAMIC */
+            }, 1032, ["id", "close-on-content-click", "preset", "onOpen"])
+          ];
+        }),
+        append: withCtx(() => [
+          createVNode(_component_c_icon, {
+            name: unref(IconAliases).DROPDOWN,
+            size: "20"
+          }, null, 8, ["name"])
+        ]),
+        details: withCtx(({ errorMessage }) => [
+          createElementVNode(
+            "span",
+            null,
+            toDisplayString(errorMessage),
+            1
+            /* TEXT */
+          )
+        ]),
+        _: 2
+        /* DYNAMIC */
+      }, [
+        renderList(_ctx.$slots, (_, slotName) => {
+          return {
+            name: slotName,
+            fn: withCtx((data) => [
+              renderSlot(_ctx.$slots, slotName, normalizeProps(guardReactiveProps(data)))
+            ])
+          };
+        })
+      ]), 1040, ["modelValue"]);
+    };
+  }
+});
+
+export { _sfc_main as default };

package/dist/components/CAutocomplete/index.js

@@ -0,0 +1,5 @@
+import _sfc_main from './CAutocomplete.js';
+
+
+
+export { _sfc_main as default };

package/dist/components/CBtn/CBtn.js

@@ -0,0 +1,51 @@
+import { defineComponent, computed, unref, openBlock, createElementBlock, normalizeClass, createElementVNode, renderSlot } from 'vue';
+import { useButtonPresets } from '../../composables/use-button-presets.js';
+
+var _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{
+    name: "CBtn"
+  },
+  __name: "CBtn",
+  props: {
+    preset: {},
+    variant: {},
+    block: { type: Boolean }
+  },
+  setup(__props) {
+    const props = __props;
+    const preset = useButtonPresets({ props });
+    const classes = computed(() => [
+      {
+        "c-btn--flat": !props.variant || props.variant === "flat",
+        "c-btn--outlined": props.variant === "outlined",
+        "c-btn--block": props.block
+      },
+      ...unref(preset).root
+    ]);
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock(
+        "button",
+        {
+          class: normalizeClass(["c-btn", classes.value])
+        },
+        [
+          createElementVNode(
+            "div",
+            {
+              class: normalizeClass(["c-btn__label", unref(preset).label])
+            },
+            [
+              renderSlot(_ctx.$slots, "default")
+            ],
+            2
+            /* CLASS */
+          )
+        ],
+        2
+        /* CLASS */
+      );
+    };
+  }
+});
+
+export { _sfc_main as default };

package/dist/components/CBtn/index.js

@@ -0,0 +1,5 @@
+import _sfc_main from './CBtn.js';
+
+
+
+export { _sfc_main as default };

package/dist/components/CCard/index.js

@@ -0,0 +1,8 @@
+import { createFunctionalComponent } from '../../utils/create-simple-functional.js';
+
+const CCard = createFunctionalComponent("c-card");
+const CCardHeader = createFunctionalComponent("c-card-header");
+const CCardBody = createFunctionalComponent("c-card-body");
+const CCardFooter = createFunctionalComponent("c-card-footer");
+
+export { CCard, CCardBody, CCardFooter, CCardHeader };

package/dist/components/CCheckbox/CCheckbox.js

@@ -0,0 +1,86 @@
+import { defineComponent, useModel, computed, onMounted, onBeforeUnmount, openBlock, createBlock, unref, mergeProps, withCtx, createElementVNode, normalizeClass, renderSlot, createVNode, withMemo, createTextVNode, toDisplayString, mergeModels } from 'vue';
+import _sfc_main$1 from '../CSelectControl/CSelectControl.js';
+import _sfc_main$2 from '../CIcon/CIcon.js';
+import { useValidate } from '../../composables/use-validate.js';
+import { useForm } from '../../composables/use-form.js';
+import { IconAliases } from '../../enums/IconName.js';
+import { CLabel } from '../CLabel/CLabel.js';
+
+const _hoisted_1 = ["aria-checked", "aria-disabled", "onClick"];
+const _hoisted_2 = { class: "c-checkbox__icon" };
+const _hoisted_3 = { class: "c-checkbox__label" };
+var _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{
+    name: "CCheckbox"
+  },
+  __name: "CCheckbox",
+  props: /* @__PURE__ */ mergeModels({
+    rules: {},
+    modelValue: { type: [Array, Boolean] },
+    label: {},
+    size: {}
+  }, {
+    "modelValue": {},
+    "modelModifiers": {}
+  }),
+  emits: ["update:modelValue"],
+  setup(__props) {
+    const props = __props;
+    const model = useModel(__props, "modelValue");
+    const { validate, errors } = useValidate(props, {});
+    const form = useForm();
+    const { CHECKBOX_ON, CHECKBOX_OFF } = IconAliases;
+    const classes = computed(() => ({
+      "c-checkbox--error": errors.hasError
+    }));
+    onMounted(() => {
+      form == null ? void 0 : form.add(validate);
+    });
+    onBeforeUnmount(() => {
+      form == null ? void 0 : form.remove(validate);
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(_sfc_main$1), mergeProps(_ctx.$attrs, {
+        modelValue: model.value,
+        "onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => model.value = $event)
+      }), {
+        default: withCtx(({ checked, toggle, disabled }) => [
+          createElementVNode("div", {
+            class: normalizeClass(["c-checkbox", classes.value]),
+            role: "checkbox",
+            "aria-checked": checked,
+            "aria-disabled": disabled,
+            onClick: toggle
+          }, [
+            createElementVNode("div", _hoisted_2, [
+              renderSlot(_ctx.$slots, "icon", { checked }, () => [
+                createVNode(unref(_sfc_main$2), {
+                  name: checked ? unref(CHECKBOX_ON) : unref(CHECKBOX_OFF)
+                }, null, 8, ["name"])
+              ])
+            ]),
+            createElementVNode("div", _hoisted_3, [
+              renderSlot(_ctx.$slots, "default", {}, () => [
+                withMemo([__props.label], () => createVNode(unref(CLabel), null, {
+                  default: withCtx(() => [
+                    createTextVNode(
+                      toDisplayString(__props.label),
+                      1
+                      /* TEXT */
+                    )
+                  ]),
+                  _: 1
+                  /* STABLE */
+                }), _cache, 0)
+              ])
+            ])
+          ], 10, _hoisted_1)
+        ]),
+        _: 3
+        /* FORWARDED */
+      }, 16, ["modelValue"]);
+    };
+  }
+});
+
+export { _sfc_main as default };

package/dist/components/CCheckbox/index.js

@@ -0,0 +1,5 @@
+import _sfc_main from './CCheckbox.js';
+
+
+
+export { _sfc_main as default };

package/dist/components/CDialog/CDialog.js

@@ -0,0 +1,95 @@
+import { defineComponent, useModel, watch, resolveComponent, openBlock, createBlock, unref, withCtx, createVNode, Transition, normalizeStyle, createCommentVNode, createElementBlock, withDirectives, renderSlot, mergeModels } from 'vue';
+import { useApplication } from '../../composables/use-application.js';
+import _sfc_main$1 from '../COverlay/COverlay.js';
+import { vClickOutside } from '../../directives/v-click-outside.js';
+
+const _hoisted_1 = { class: "c-dialog__content" };
+var _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{
+    name: "CDialog"
+  },
+  __name: "CDialog",
+  props: /* @__PURE__ */ mergeModels({
+    modelValue: { type: Boolean },
+    to: {},
+    closeOnClickOutside: { type: Boolean }
+  }, {
+    "modelValue": { type: Boolean, ...{ default: false } },
+    "modelModifiers": {}
+  }),
+  emits: ["update:modelValue"],
+  setup(__props) {
+    const props = __props;
+    const { blockScroll, unblockScroll } = useApplication();
+    const model = useModel(__props, "modelValue");
+    const onOutsideClick = () => {
+      if (props.closeOnClickOutside) {
+        model.value = false;
+      }
+    };
+    watch(model, (value) => {
+      if (value) blockScroll();
+      else unblockScroll();
+    });
+    return (_ctx, _cache) => {
+      const _component_c_scrim = resolveComponent("c-scrim");
+      return openBlock(), createBlock(unref(_sfc_main$1), {
+        modelValue: model.value,
+        "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => model.value = $event)
+      }, {
+        default: withCtx(({ zIndex }) => [
+          createVNode(
+            Transition,
+            { name: "fade" },
+            {
+              default: withCtx(() => [
+                model.value ? (openBlock(), createBlock(_component_c_scrim, {
+                  key: 0,
+                  blur: "",
+                  style: normalizeStyle({ zIndex })
+                }, null, 8, ["style"])) : createCommentVNode("v-if", true)
+              ]),
+              _: 2
+              /* DYNAMIC */
+            },
+            1024
+            /* DYNAMIC_SLOTS */
+          ),
+          createVNode(
+            Transition,
+            { name: "scale-in" },
+            {
+              default: withCtx(() => [
+                model.value ? (openBlock(), createElementBlock(
+                  "div",
+                  {
+                    key: 0,
+                    class: "c-dialog",
+                    style: normalizeStyle({ zIndex })
+                  },
+                  [
+                    withDirectives((openBlock(), createElementBlock("div", _hoisted_1, [
+                      renderSlot(_ctx.$slots, "default")
+                    ])), [
+                      [unref(vClickOutside), onOutsideClick]
+                    ])
+                  ],
+                  4
+                  /* STYLE */
+                )) : createCommentVNode("v-if", true)
+              ]),
+              _: 2
+              /* DYNAMIC */
+            },
+            1024
+            /* DYNAMIC_SLOTS */
+          )
+        ]),
+        _: 3
+        /* FORWARDED */
+      }, 8, ["modelValue"]);
+    };
+  }
+});
+
+export { _sfc_main as default };

package/dist/components/CDialog/CDialogsStack.js

@@ -0,0 +1,27 @@
+import { defineComponent, openBlock, createBlock, unref, withCtx, resolveDynamicComponent, normalizeProps, mergeProps, createCommentVNode } from 'vue';
+import { useDialogsStack } from '../../composables/use-dialogs-stack.js';
+import _sfc_main$1 from '../COverlay/COverlay.js';
+
+var _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "CDialogsStack",
+  setup(__props) {
+    const { current } = useDialogsStack();
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(_sfc_main$1), { "model-value": true }, {
+        default: withCtx(() => [
+          unref(current) ? (openBlock(), createBlock(
+            resolveDynamicComponent(unref(current).component),
+            normalizeProps(mergeProps({ key: 0 }, unref(current).props)),
+            null,
+            16
+            /* FULL_PROPS */
+          )) : createCommentVNode("v-if", true)
+        ]),
+        _: 1
+        /* STABLE */
+      });
+    };
+  }
+});
+
+export { _sfc_main as default };

package/dist/components/CDialog/index.js

@@ -0,0 +1,5 @@
+import _sfc_main from './CDialog.js';
+
+
+
+export { _sfc_main as default };

package/dist/components/CDialog/index2.js

@@ -0,0 +1,5 @@
+import _sfc_main from './CDialogsStack.js';
+
+
+
+export { _sfc_main as default };

package/dist/components/CField/CField.js

@@ -0,0 +1,51 @@
+import { defineComponent, useModel, shallowRef, useAttrs, computed, unref, onMounted, openBlock, createBlock, resolveDynamicComponent, normalizeClass, mergeModels } from 'vue';
+
+var _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{
+    name: "CField"
+  },
+  __name: "CField",
+  props: /* @__PURE__ */ mergeModels({
+    tag: { default: "input" },
+    focused: { type: Boolean }
+  }, {
+    "modelValue": {},
+    "modelModifiers": {}
+  }),
+  emits: /* @__PURE__ */ mergeModels(["focus"], ["update:modelValue"]),
+  setup(__props, { emit: __emit }) {
+    const emit = __emit;
+    const input = useModel(__props, "modelValue");
+    const inputRef = shallowRef();
+    const attrs = useAttrs();
+    const classes = computed(() => ({
+      "c-field--focused": __props.focused,
+      "c-field--filled": !!unref(input)
+    }));
+    const onFocus = () => {
+      if (attrs.readonly || attrs.disabled) {
+        return;
+      }
+      emit("focus");
+    };
+    const onInput = (e) => {
+      input.value = e.target.value;
+    };
+    onMounted(() => {
+      var _a;
+      if (__props.focused) (_a = unref(inputRef)) == null ? void 0 : _a.focus();
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(resolveDynamicComponent(__props.tag), {
+        ref_key: "inputRef",
+        ref: inputRef,
+        class: normalizeClass(["c-field", classes.value]),
+        value: input.value,
+        onInput,
+        onFocus
+      }, null, 40, ["class", "value"]);
+    };
+  }
+});
+
+export { _sfc_main as default };

package/dist/components/CField/index.js

@@ -0,0 +1,5 @@
+import _sfc_main from './CField.js';
+
+
+
+export { _sfc_main as default };

package/dist/components/CForm/CForm.js

@@ -0,0 +1,45 @@
+import { defineComponent, provide, openBlock, createElementBlock, withModifiers, renderSlot } from 'vue';
+import { $FORM_API_KEY } from '../../constants/provide-keys.js';
+
+var _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{
+    name: "CForm"
+  },
+  __name: "CForm",
+  setup(__props, { expose: __expose }) {
+    let validators = [];
+    function add(fn) {
+      validators.push(fn);
+    }
+    function remove(fn) {
+      validators = validators.filter((v) => v !== fn);
+    }
+    async function validate() {
+      return validators.map((fn) => fn()).every((v) => v);
+    }
+    __expose({
+      validate
+    });
+    provide($FORM_API_KEY, {
+      add,
+      remove
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock(
+        "form",
+        {
+          class: "c-form",
+          onSubmit: _cache[0] || (_cache[0] = withModifiers(() => {
+          }, ["prevent"]))
+        },
+        [
+          renderSlot(_ctx.$slots, "default", { validate })
+        ],
+        32
+        /* NEED_HYDRATION */
+      );
+    };
+  }
+});
+
+export { _sfc_main as default };

package/dist/components/CForm/index.js

@@ -0,0 +1,5 @@
+import _sfc_main from './CForm.js';
+
+
+
+export { _sfc_main as default };