eco-vue-js 0.3.67

package/dist/components/FilePicker/components/FilePickerItem.vue.js

@@ -0,0 +1,47 @@
+import { defineComponent, openBlock, createElementBlock, renderSlot, createVNode, unref, createElementVNode, toDisplayString, withModifiers } from 'vue';
+import IconCancel from '../../../assets/icons/default/IconCancel.svg.js';
+import IconCheckCircle from '../../../assets/icons/sax/IconCheckCircle.svg.js';
+import IconCloseCircle from '../../../assets/icons/sax/IconCloseCircle.svg.js';
+
+const _hoisted_1 = { class: "relative height-52 width-44 flex flex-col gap-2" };
+const _hoisted_2 = {
+  key: 0,
+  class: "square-44 flex items-center justify-center"
+};
+const _hoisted_3 = {
+  key: 1,
+  class: "square-44 flex items-center justify-center"
+};
+const _hoisted_4 = { class: "text-base text-accent text-center font-normal truncate" };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "FilePickerItem",
+  props: {
+    name: {},
+    hasError: { type: Boolean }
+  },
+  emits: ["click:cancel"],
+  setup(__props) {
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1, [
+        !_ctx.hasError ? (openBlock(), createElementBlock("div", _hoisted_2, [
+          renderSlot(_ctx.$slots, "positive", {}, () => [
+            createVNode(unref(IconCheckCircle), { class: "square-36 text-positive dark:text-positive-dark" })
+          ])
+        ])) : (openBlock(), createElementBlock("div", _hoisted_3, [
+          renderSlot(_ctx.$slots, "negative", {}, () => [
+            createVNode(unref(IconCloseCircle), { class: "square-36 text-negative dark:text-negative-dark" })
+          ])
+        ])),
+        createElementVNode("div", _hoisted_4, toDisplayString(_ctx.name), 1),
+        createElementVNode("button", {
+          class: "absolute top-0 right-0 w-ripple flex square-5 rounded-full items-center justify-center hover:bg-opacity-5 hover:bg-black-default outline-none",
+          onClick: _cache[0] || (_cache[0] = withModifiers(($event) => _ctx.$emit("click:cancel"), ["stop", "prevent"]))
+        }, [
+          createVNode(unref(IconCancel), { class: "square-3 text-description" })
+        ])
+      ]);
+    };
+  }
+});
+
+export { _sfc_main as default };

package/dist/components/FilePicker/components/FilePickerItem.vue2.js

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

package/dist/components/FilePicker/components/FilePickerSvg.vue.d.ts

@@ -0,0 +1,33 @@
+declare const _default: import("vue").DefineComponent<{
+    svgWidth: {
+        type: import("vue").PropType<number>;
+        required: true;
+    };
+    svgHeight: {
+        type: import("vue").PropType<number>;
+        required: true;
+    };
+    isActive: {
+        type: import("vue").PropType<boolean>;
+    };
+    hasError: {
+        type: import("vue").PropType<boolean>;
+    };
+}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    svgWidth: {
+        type: import("vue").PropType<number>;
+        required: true;
+    };
+    svgHeight: {
+        type: import("vue").PropType<number>;
+        required: true;
+    };
+    isActive: {
+        type: import("vue").PropType<boolean>;
+    };
+    hasError: {
+        type: import("vue").PropType<boolean>;
+    };
+}>>, {}, {}>;
+export default _default;
+//# sourceMappingURL=FilePickerSvg.vue.d.ts.map

package/dist/components/FilePicker/components/FilePickerSvg.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FilePickerSvg.vue.d.ts","sourceRoot":"","sources":["../../../../../src/components/FilePicker/components/FilePickerSvg.vue.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuIA,wBAAkD"}

package/dist/components/FilePicker/components/FilePickerSvg.vue.js

@@ -0,0 +1,84 @@
+import { defineComponent, ref, computed, watch, toRef, onBeforeMount, openBlock, createElementBlock, normalizeClass, createElementVNode, normalizeStyle } from 'vue';
+
+const _hoisted_1 = ["width", "height"];
+const _hoisted_2 = ["x", "y", "width", "height", "rx", "ry", "stroke-width", "stroke-dasharray", "stroke-dashoffset"];
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "FilePickerSvg",
+  props: {
+    svgWidth: {},
+    svgHeight: {},
+    isActive: { type: Boolean },
+    hasError: { type: Boolean }
+  },
+  setup(__props) {
+    const props = __props;
+    const lengthList = Array(8).fill(void 0).map((_, index) => (7 + index * 2) * 4);
+    const borderRaduis = ref(12);
+    const strokeWidth = ref(4);
+    const svgRect = ref();
+    const fraction = ref(48);
+    const fractionShift = ref(0);
+    const rectWidth = computed(() => props.svgWidth - strokeWidth.value);
+    const rectHeight = computed(() => props.svgHeight - strokeWidth.value);
+    const roundedHalf = computed(() => 12 * Math.PI / 2);
+    const pathLength = computed(() => svgRect.value?.getTotalLength() ?? 480);
+    const segmentLength = computed(() => pathLength.value / fraction.value);
+    const dashoffset = computed(() => (segmentLength.value + roundedHalf.value) / 2);
+    const calcFaction = () => {
+      const factor = rectWidth.value / rectHeight.value;
+      let result = 2;
+      let index = 0;
+      for (let i = 0; i < lengthList.length; i++) {
+        const value = lengthList[i] * factor % 1;
+        if (result > value) {
+          result = value;
+          index = i;
+        }
+      }
+      fraction.value = lengthList[index] ?? 48;
+      fractionShift.value = result;
+    };
+    watch(toRef(props, "svgWidth"), calcFaction);
+    onBeforeMount(() => {
+      calcFaction();
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("svg", {
+        class: normalizeClass({
+          "opacity-50": !_ctx.isActive,
+          "opacity-100": _ctx.isActive,
+          "text-negative dark:text-negative-dark": _ctx.hasError,
+          "text-primary-default dark:text-primary-dark": !_ctx.hasError
+        }),
+        width: _ctx.svgWidth,
+        height: _ctx.svgHeight
+      }, [
+        createElementVNode("rect", {
+          ref_key: "svgRect",
+          ref: svgRect,
+          x: strokeWidth.value / 2,
+          y: strokeWidth.value / 2,
+          width: rectWidth.value,
+          height: rectHeight.value,
+          rx: borderRaduis.value,
+          ry: borderRaduis.value,
+          "stroke-width": strokeWidth.value,
+          "stroke-dasharray": segmentLength.value + " " + segmentLength.value,
+          "stroke-dashoffset": dashoffset.value,
+          "stroke-linecap": "round",
+          stroke: "currentColor",
+          fill: "none",
+          class: normalizeClass({
+            "animate-border-rotate": _ctx.isActive
+          }),
+          style: normalizeStyle({
+            "--border-rotate-offset-from": dashoffset.value,
+            "--border-rotate-offset-to": dashoffset.value - pathLength.value
+          })
+        }, null, 14, _hoisted_2)
+      ], 10, _hoisted_1);
+    };
+  }
+});
+
+export { _sfc_main as default };

package/dist/components/FilePicker/components/FilePickerSvg.vue2.js

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

package/dist/components/Form/WForm.vue.d.ts

@@ -0,0 +1,38 @@
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{
+    name: {
+        type: import("vue").PropType<string>;
+    };
+    title: {
+        type: import("vue").PropType<string>;
+    };
+}, {
+    isValid: import("vue").ComputedRef<boolean>;
+    validate: (silent?: boolean | undefined) => string | undefined;
+    invalidate: (payload: {
+        [x: string]: string | string[];
+    }) => void;
+    initModel: () => void;
+    errorMessage: import("vue").ComputedRef<string>;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:isValid": (value: boolean | undefined) => void;
+    "update:hasChanges": (value: boolean) => void;
+}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    name: {
+        type: import("vue").PropType<string>;
+    };
+    title: {
+        type: import("vue").PropType<string>;
+    };
+}>> & {
+    "onUpdate:isValid"?: ((value: boolean | undefined) => any) | undefined;
+    "onUpdate:hasChanges"?: ((value: boolean) => any) | undefined;
+}, {}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+//# sourceMappingURL=WForm.vue.d.ts.map

package/dist/components/Form/WForm.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WForm.vue.d.ts","sourceRoot":"","sources":["../../../../src/components/Form/WForm.vue.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuIA,wBAA8G;AAmB9G,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IAAE,QAAO;QAClD,MAAM,EAAE,CAAC,CAAC;KACT,CAAA;CAAE,CAAC"}

package/dist/components/Form/WForm.vue.js

@@ -0,0 +1,59 @@
+import { defineComponent, computed, toRef, provide, inject, watch, onBeforeUnmount, openBlock, createElementBlock, renderSlot } from 'vue';
+import { wFormUnlistener } from './models/injection.js';
+import { useFormErrorMessageMap } from './use/useFormErrorMessageMap.js';
+import { useFormHasChangesMap } from './use/useFormHasChangesMap.js';
+import { useFormInitModelMap } from './use/useFormInitModelMap.js';
+import { useFormInvalidateMap } from './use/useFormInvalidateMap.js';
+import { useFormTitleMap } from './use/useFormTitleMap.js';
+import { useFormValidateMap } from './use/useFormValidateMap.js';
+
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "WForm",
+  props: {
+    name: {},
+    title: {}
+  },
+  emits: ["update:isValid", "update:hasChanges"],
+  setup(__props, { expose: __expose, emit }) {
+    const props = __props;
+    const name = computed(() => props.name);
+    const { titleGetter, titleMapUnlistener } = useFormTitleMap(name, toRef(props, "title"));
+    const { errorMessageMapUnlistener, isValid, errorMessage } = useFormErrorMessageMap(name, titleGetter);
+    const { hasChangesMapUnlistener, hasChanges } = useFormHasChangesMap(name);
+    const { validateMapUnlistener, validate } = useFormValidateMap(name, titleGetter, (value) => emit("update:isValid", value));
+    const { invalidateMapUnlistener, invalidate } = useFormInvalidateMap(name);
+    const { initModelMapUnlistener, initModel } = useFormInitModelMap(name);
+    const unlistener = (key) => {
+      titleMapUnlistener(key);
+      errorMessageMapUnlistener(key);
+      hasChangesMapUnlistener(key);
+      validateMapUnlistener(key);
+      invalidateMapUnlistener(key);
+      initModelMapUnlistener(key);
+    };
+    provide(wFormUnlistener, unlistener);
+    const unlistenerInjected = inject(wFormUnlistener, void 0);
+    watch(isValid, (value) => emit("update:isValid", value));
+    watch(hasChanges, (value) => emit("update:hasChanges", value));
+    onBeforeUnmount(() => {
+      if (props.name) {
+        unlistenerInjected?.(props.name);
+      }
+      emit("update:isValid", void 0);
+    });
+    __expose({
+      isValid,
+      validate,
+      invalidate,
+      initModel,
+      errorMessage
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", null, [
+        renderSlot(_ctx.$slots, "default")
+      ]);
+    };
+  }
+});
+
+export { _sfc_main as default };

package/dist/components/Form/WForm.vue2.js

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

package/dist/components/Form/WFormValidator.vue.d.ts

@@ -0,0 +1,50 @@
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{
+    name: {
+        type: import("vue").PropType<string>;
+    };
+    title: {
+        type: import("vue").PropType<string>;
+    };
+    validate: {
+        type: import("vue").PropType<ValidateFn | ValidateFn[]>;
+    };
+    forbiddenRegexp: {
+        type: import("vue").PropType<RegExp>;
+    };
+    requiredSymbols: {
+        type: import("vue").PropType<string>;
+    };
+}, {
+    validateOnUpdate(): string | undefined;
+    invalidate(message: string): void;
+    initModel: () => void;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:has-changes": (value: boolean) => void;
+}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    name: {
+        type: import("vue").PropType<string>;
+    };
+    title: {
+        type: import("vue").PropType<string>;
+    };
+    validate: {
+        type: import("vue").PropType<ValidateFn | ValidateFn[]>;
+    };
+    forbiddenRegexp: {
+        type: import("vue").PropType<RegExp>;
+    };
+    requiredSymbols: {
+        type: import("vue").PropType<string>;
+    };
+}>> & {
+    "onUpdate:has-changes"?: ((value: boolean) => any) | undefined;
+}, {}, {}>, {
+    default: () => void;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+//# sourceMappingURL=WFormValidator.vue.d.ts.map

package/dist/components/Form/WFormValidator.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WFormValidator.vue.d.ts","sourceRoot":"","sources":["../../../../src/components/Form/WFormValidator.vue.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+TA,wBAA8G;AAiB9G,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IAAE,QAAO;QAClD,MAAM,EAAE,CAAC,CAAC;KACT,CAAA;CAAE,CAAC"}

package/dist/components/Form/WFormValidator.vue.js

@@ -0,0 +1,199 @@
+import { defineComponent, inject, useSlots, computed, ref, watch, onBeforeMount, onBeforeUnmount, openBlock, createBlock, resolveDynamicComponent } from 'vue';
+import { wFormTitleUpdater, wFormErrorMessageUpdater, wFormHasChangesUpdater, wFormValidateUpdater, wFormInvalidateUpdater, wFormInitModelUpdater, wFormUnlistener } from './models/injection.js';
+
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "WFormValidator",
+  props: {
+    name: {},
+    title: {},
+    validate: {},
+    forbiddenRegexp: {},
+    requiredSymbols: {}
+  },
+  emits: ["update:has-changes"],
+  setup(__props, { expose: __expose, emit }) {
+    const props = __props;
+    const titleUpdater = inject(wFormTitleUpdater, void 0);
+    const errorMessageUpdater = inject(wFormErrorMessageUpdater, void 0);
+    const hasChangesUpdater = inject(wFormHasChangesUpdater, void 0);
+    const validateUpdater = inject(wFormValidateUpdater, void 0);
+    const invalidateUpdater = inject(wFormInvalidateUpdater, void 0);
+    const initModelUpdater = inject(wFormInitModelUpdater, void 0);
+    const unlistener = inject(wFormUnlistener, void 0);
+    const slots = useSlots();
+    const component = computed(() => slots.default?.()[0]);
+    const modelValue = computed(() => {
+      const props2 = component.value?.props;
+      if (!props2)
+        return void 0;
+      if ("modelValue" in props2) {
+        return props2.modelValue;
+      }
+      if ("model-value" in props2) {
+        return props2["model-value"];
+      }
+      return void 0;
+    });
+    const initModelValue = ref();
+    const required = computed(() => component.value?.props?.required !== void 0 ? component.value?.props?.required !== false : void 0);
+    const title = computed(() => props.title ?? component.value?.props?.title);
+    const errorMessage = ref();
+    const hasChanges = ref(false);
+    const hasBeenValidated = ref(false);
+    const requiredSymbols = computed(() => props.requiredSymbols?.split("") ?? []);
+    const _updateHasChanges = (value) => {
+      if (initModelValue.value === void 0) {
+        hasChanges.value = value !== void 0 && value !== "";
+      } else {
+        if (value instanceof Array && initModelValue.value instanceof Array) {
+          const oldValue = initModelValue.value;
+          const newValue = value;
+          hasChanges.value = newValue.length !== oldValue.length || newValue.some((item) => !oldValue.includes(item));
+        } else {
+          hasChanges.value = value !== initModelValue.value;
+        }
+      }
+    };
+    const _validate = (value) => {
+      if (required.value && !value) {
+        const message2 = "A value is required";
+        return message2;
+      }
+      if (props.forbiddenRegexp && typeof value === "string") {
+        const match = value.match(props.forbiddenRegexp);
+        if (match?.length) {
+          const message2 = "The following symbols are not allowed: " + match.filter((item, index) => match.indexOf(item) === index).map((item) => {
+            switch (item) {
+              case " ":
+                return "whitespace";
+              case "\n":
+                return "line break";
+              default:
+                return `" ${item} "`;
+            }
+          }).join(", ");
+          return message2;
+        }
+      }
+      if (props.requiredSymbols && typeof value === "string") {
+        const match = requiredSymbols.value.filter((item) => !value.includes(item)).map((item) => {
+          switch (item) {
+            case " ":
+              return "whitespace";
+            case "\n":
+              return "line break";
+            case "	":
+              return "tabulation";
+            default:
+              return `${item}`;
+          }
+        }).join(", ");
+        if (match.length)
+          return "Please include the required symbols: " + match;
+      }
+      let message;
+      if (props.validate instanceof Array) {
+        message = props.validate.map((cb) => cb(value)).filter((item) => item).join(", ") || void 0;
+      } else {
+        message = props.validate?.(value) || void 0;
+      }
+      return message;
+    };
+    const validateOnUpdate = (value) => {
+      const message = _validate(value);
+      _updateHasChanges(value);
+      errorMessage.value = message;
+      hasBeenValidated.value = true;
+      return message;
+    };
+    const _validateOnUpdate = (value) => {
+      validateOnUpdate(value);
+    };
+    const _validateOnSelect = (value) => {
+      const newValue = modelValue.value instanceof Array ? modelValue.value.slice() : [];
+      newValue.push(value);
+      validateOnUpdate(newValue);
+    };
+    const _validateOnUnselect = (value) => {
+      const newValue = modelValue.value instanceof Array ? modelValue.value.slice() : [];
+      const index = newValue.indexOf(value);
+      if (index !== -1)
+        newValue.splice(index, 1);
+      validateOnUpdate(newValue);
+    };
+    const validate = (silent) => {
+      const message = _validate(modelValue.value);
+      if (!silent) {
+        errorMessage.value = message;
+        hasBeenValidated.value = true;
+      }
+      return message;
+    };
+    const invalidate = (messages) => {
+      if (!props.name)
+        return;
+      const message = messages[props.name];
+      if (typeof message === "string")
+        errorMessage.value = message;
+      else if (message instanceof Array)
+        errorMessage.value = message.join(", ");
+    };
+    const initModel = () => {
+      initModelValue.value = modelValue.value;
+      hasChanges.value = false;
+    };
+    watch(errorMessage, (value) => {
+      if (props.name) {
+        errorMessageUpdater?.(props.name, value);
+      }
+    });
+    watch(hasChanges, (value) => {
+      if (props.name) {
+        hasChangesUpdater?.(props.name, value);
+      }
+      emit("update:has-changes", value);
+    });
+    watch(title, (value) => {
+      if (props.name) {
+        titleUpdater?.(props.name, value);
+      }
+    }, { immediate: true });
+    watch(required, () => {
+      if (hasBeenValidated.value)
+        validate();
+    });
+    onBeforeMount(() => {
+      if (props.name) {
+        initModel();
+        validateUpdater?.(props.name, validate);
+        invalidateUpdater?.(props.name, invalidate);
+        initModelUpdater?.(props.name, initModel);
+      }
+    });
+    onBeforeUnmount(() => {
+      if (props.name) {
+        unlistener?.(props.name);
+      }
+    });
+    __expose({
+      validateOnUpdate() {
+        return validateOnUpdate(modelValue.value);
+      },
+      invalidate(message) {
+        errorMessage.value = message;
+      },
+      initModel
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(resolveDynamicComponent(component.value), {
+        "error-message": errorMessage.value,
+        "has-changes": hasChanges.value,
+        "onUpdate:modelValue": _validateOnUpdate,
+        onSelect: _validateOnSelect,
+        onUnselect: _validateOnUnselect
+      }, null, 40, ["error-message", "has-changes"]);
+    };
+  }
+});
+
+export { _sfc_main as default };

package/dist/components/Form/WFormValidator.vue2.js

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

package/dist/components/Form/models/injection.d.ts

@@ -0,0 +1,9 @@
+import type { InjectionKey } from 'vue';
+export declare const wFormTitleUpdater: InjectionKey<(key: string, value: string | undefined) => void>;
+export declare const wFormErrorMessageUpdater: InjectionKey<(key: string, value: string | undefined) => void>;
+export declare const wFormHasChangesUpdater: InjectionKey<(key: string, value: boolean) => void>;
+export declare const wFormValidateUpdater: InjectionKey<(key: string, value: () => string | undefined) => void>;
+export declare const wFormInvalidateUpdater: InjectionKey<(key: string, value: (messages: Record<string, string | string[]>) => void) => void>;
+export declare const wFormInitModelUpdater: InjectionKey<(key: string, value: () => void) => void>;
+export declare const wFormUnlistener: InjectionKey<(key: string) => void>;
+//# sourceMappingURL=injection.d.ts.map

package/dist/components/Form/models/injection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"injection.d.ts","sourceRoot":"","sources":["../../../../../src/components/Form/models/injection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,KAAK,CAAA;AAErC,eAAO,MAAM,iBAAiB,qBAAqD,MAAM,SAAS,MAAM,GAAG,SAAS,KAAK,IAAI,CAAC,CAAA;AAE9H,eAAO,MAAM,wBAAwB,qBAA4D,MAAM,SAAS,MAAM,GAAG,SAAS,KAAK,IAAI,CAAC,CAAA;AAE5I,eAAO,MAAM,sBAAsB,qBAA0D,MAAM,SAAS,OAAO,KAAK,IAAI,CAAC,CAAA;AAE7H,eAAO,MAAM,oBAAoB,qBAAwD,MAAM,SAAS,MAAM,MAAM,GAAG,SAAS,KAAK,IAAI,CAAC,CAAA;AAE1I,eAAO,MAAM,sBAAsB,qBAAwD,MAAM,oBAAoB,OAAO,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC,KAAK,IAAI,KAAK,IAAI,CAAC,CAAA;AAEzK,eAAO,MAAM,qBAAqB,qBAAyD,MAAM,SAAS,MAAM,IAAI,KAAK,IAAI,CAAC,CAAA;AAE9H,eAAO,MAAM,eAAe,qBAAmD,MAAM,KAAK,IAAI,CAAC,CAAA"}

package/dist/components/Form/models/injection.js

@@ -0,0 +1,9 @@
+const wFormTitleUpdater = Symbol("wFormTitleUpdater");
+const wFormErrorMessageUpdater = Symbol("wFormErrorMessageUpdater");
+const wFormHasChangesUpdater = Symbol("wFormHasChangesUpdater");
+const wFormValidateUpdater = Symbol("wFormValidateUpdater");
+const wFormInvalidateUpdater = Symbol("wFormValidateUpdater");
+const wFormInitModelUpdater = Symbol("wFormInitModelUpdater");
+const wFormUnlistener = Symbol("wFormUnlistener");
+
+export { wFormErrorMessageUpdater, wFormHasChangesUpdater, wFormInitModelUpdater, wFormInvalidateUpdater, wFormTitleUpdater, wFormUnlistener, wFormValidateUpdater };

package/dist/components/Form/models/utils.d.ts

@@ -0,0 +1,3 @@
+export declare const removeKey: <T extends Record<string, unknown>>(entity: T, key: string) => T;
+export declare const compileMessage: (title: string, message: string | undefined) => string | undefined;
+//# sourceMappingURL=utils.d.ts.map

package/dist/components/Form/models/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../../src/components/Form/models/utils.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,SAAS,sDAAuD,MAAM,MAMlF,CAAA;AAKD,eAAO,MAAM,cAAc,UAAW,MAAM,WAAW,MAAM,GAAG,SAAS,KAAG,MAAM,GAAG,SAQpF,CAAA"}

package/dist/components/Form/models/utils.js

@@ -0,0 +1,19 @@
+const removeKey = (entity, key) => {
+  const result = { ...entity };
+  delete result[key];
+  return result;
+};
+const fieldMessageStart = "- ";
+const subformMessageStart = "  ";
+const compileMessage = (title, message) => {
+  if (message === void 0)
+    return void 0;
+  if (message.startsWith(fieldMessageStart) || message.startsWith(subformMessageStart)) {
+    return `${subformMessageStart}${title}:
+${message}`;
+  } else {
+    return `${fieldMessageStart}${title}: ${message}`;
+  }
+};
+
+export { compileMessage, removeKey };

package/dist/components/Form/use/useFormErrorMessageMap.d.ts

@@ -0,0 +1,7 @@
+import { type Ref } from 'vue';
+export declare const useFormErrorMessageMap: (name: Ref<string | undefined>, titleGetter: (key: string) => string) => {
+    errorMessageMapUnlistener: (key: string) => void;
+    isValid: import("vue").ComputedRef<boolean>;
+    errorMessage: import("vue").ComputedRef<string>;
+};
+//# sourceMappingURL=useFormErrorMessageMap.d.ts.map

package/dist/components/Form/use/useFormErrorMessageMap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFormErrorMessageMap.d.ts","sourceRoot":"","sources":["../../../../../src/components/Form/use/useFormErrorMessageMap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAwC,KAAK,GAAG,EAAC,MAAM,KAAK,CAAA;AAInE,eAAO,MAAM,sBAAsB,SAAU,IAAI,MAAM,GAAG,SAAS,CAAC,qBAAqB,MAAM,KAAK,MAAM;qCAQhE,MAAM;;;CAuB/C,CAAA"}

package/dist/components/Form/use/useFormErrorMessageMap.js

@@ -0,0 +1,31 @@
+import { ref, computed, provide, inject, watch } from 'vue';
+import { wFormErrorMessageUpdater } from '../models/injection.js';
+import { compileMessage, removeKey } from '../models/utils.js';
+
+const useFormErrorMessageMap = (name, titleGetter) => {
+  const errorMessageMap = ref({});
+  const isValid = computed(() => !Object.values(errorMessageMap.value).some((item) => item));
+  const errorMessageMapUpdater = (key, value) => {
+    errorMessageMap.value = !value ? removeKey(errorMessageMap.value, key) : { ...errorMessageMap.value, [key]: value };
+  };
+  const errorMessageMapUnlistener = (key) => {
+    errorMessageMap.value = removeKey(errorMessageMap.value, key);
+  };
+  const errorMessage = computed(() => {
+    return Object.keys(errorMessageMap.value).map((key) => compileMessage(titleGetter(key), errorMessageMap.value[key])).filter((item) => item).join("\n");
+  });
+  provide(wFormErrorMessageUpdater, errorMessageMapUpdater);
+  const errorMessageUpdaterInjected = inject(wFormErrorMessageUpdater, void 0);
+  watch(errorMessage, (value) => {
+    if (name.value) {
+      errorMessageUpdaterInjected?.(name.value, value);
+    }
+  });
+  return {
+    errorMessageMapUnlistener,
+    isValid,
+    errorMessage
+  };
+};
+
+export { useFormErrorMessageMap };

package/dist/components/Form/use/useFormHasChangesMap.d.ts

@@ -0,0 +1,6 @@
+import { type Ref } from 'vue';
+export declare const useFormHasChangesMap: (name: Ref<string | undefined>) => {
+    hasChangesMapUnlistener: (key: string) => void;
+    hasChanges: import("vue").ComputedRef<boolean>;
+};
+//# sourceMappingURL=useFormHasChangesMap.d.ts.map

package/dist/components/Form/use/useFormHasChangesMap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFormHasChangesMap.d.ts","sourceRoot":"","sources":["../../../../../src/components/Form/use/useFormHasChangesMap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAwC,KAAK,GAAG,EAAC,MAAM,KAAK,CAAA;AAInE,eAAO,MAAM,oBAAoB,SAAU,IAAI,MAAM,GAAG,SAAS,CAAC;mCAQ1B,MAAM;;CAkB7C,CAAA"}