@g1cloud/open-bluesea-core 1.0.0-alpha.10 → 1.0.0-alpha.11

package/dist/index.d.ts

@@ -8,6 +8,7 @@ import { ComponentOptionsBase } from 'vue';
 import { ComponentOptionsMixin } from 'vue';
 import { ComponentProvideOptions } from 'vue';
 import { ComponentPublicInstance } from 'vue';
+import { ComputedRef } from 'vue';
 import { CreateComponentPublicInstanceWithMixins } from 'vue';
 import { DebuggerEvent } from 'vue';
 import { DefineComponent } from 'vue';
@@ -1087,16 +1088,55 @@ export declare const emptyLabelProvider: <T>(_item: T) => undefined;
 
 export declare type EnabledItemProvider<T> = (item: T) => boolean;
 
+export declare const executeBetweenLengthValidation: (text: string, minLength: number | undefined, minLengthMessage: string | undefined, maxLength: number | undefined, maxLengthMessage: string | undefined, betweenLengthMessage: string | undefined, errors: ValidationError[]) => boolean;
+
+export declare const executeBetweenValueValidation: (value: number, minValue: number | undefined, minValueMessage: string | undefined, maxValue: number | undefined, maxValueMessage: string | undefined, betweenValueMessage: string | undefined, errors: ValidationError[]) => boolean;
+
+export declare const executeDateRangeValidation: (fromValue: string | undefined, toValue: string | undefined, validationMessage: string | undefined, erros: ValidationError[]) => boolean;
+
+export declare const executeFieldValidationRule: <T>(value: T, rules: FieldValidationRule<T>[] | undefined, errors: ValidationError[], phase: ValidationPhase, fieldContext?: FieldContext<any>) => Promise<boolean>;
+
 export declare const executeKeyProviderOrDefault: <T>(item: T, keyProvider: KeyProvider<T> | undefined, defaultKey: (item: T) => string) => string;
 
 export declare const executeLabelProviderOrDefault: <T>(item: T, labelProvider: LabelProvider<T> | undefined, defaultLabel: (item: T) => string) => string;
 
+export declare const executeRegExpValidation: (value: string, regexp: string | undefined, message: string | undefined, errors: ValidationError[]) => boolean;
+
+export declare const executeRequiredValidation: (value: string | number | undefined, checkRequired: boolean, requiredMessage: string | undefined, errors: ValidationError[]) => boolean;
+
 export declare type FieldContext<T> = {
     iteration?: IterationContext<T>;
     locale?: LocaleName;
 };
 
-declare type FieldValidationRule<T> = (value: T, phase: ValidationPhase, fieldContext?: FieldContext<any>) => Promise<ValidationError[] | undefined> | ValidationError[] | undefined;
+export declare type FieldValidationRule<T> = (value: T, phase: ValidationPhase, fieldContext?: FieldContext<any>) => Promise<ValidationError[] | undefined> | ValidationError[] | undefined;
+
+export declare type FieldValidator<T> = {
+    stringValue: Ref<string | undefined>;
+    value: Ref<UnwrapRef<T> | undefined>;
+    valid: Ref<boolean>;
+    errors: Ref<ValidationError[]>;
+    touched: Ref<boolean>;
+    handleInput: (event: Event) => Promise<void>;
+    handleChange: (event: Event) => Promise<void>;
+    handleFocus: (event: Event) => void;
+    handleBlur: (event: Event) => void;
+    validateValue: (value: UnwrapRef<T>, phase: ValidationPhase) => Promise<void>;
+    validate: (phase?: ValidationPhase) => Promise<void>;
+    clearErrors: () => void;
+    getName: () => string;
+};
+
+export declare const fieldValidator: <T>(option: FieldValidatorOption<T>) => FieldValidator<T>;
+
+export declare type FieldValidatorOption<T> = {
+    field?: Ref<HTMLElement | undefined>;
+    disabled: Ref<boolean> | ComputedRef<boolean>;
+    initialValue?: T;
+    isValid?: (value: UnwrapRef<T> | undefined, phase: ValidationPhase) => undefined | ValidationError[] | Promise<ValidationError[]>;
+    convertToValue?: (value: string | undefined) => UnwrapRef<T>;
+    convertFromValue?: (value: UnwrapRef<T | undefined>) => string;
+};
 
 /**
  * HTMLElement, Component(vue) 로부터 실제 HTMLElement 를 찾아온다.
@@ -1120,6 +1160,8 @@ declare type FieldValidationRule<T> = (value: T, phase: ValidationPhase, fieldCo
  */
 export declare const findElement: (maybeElement: Ref<HTMLElement | Component | undefined | null> | undefined) => HTMLElement | undefined;
 
+export declare const findFieldValidatorElements: (element?: HTMLElement) => NodeListOf<HTMLElement> | undefined;
+
 /**
  * 첫 번재 focusable 한 element 를 찾는다.
  * @param element
@@ -1217,6 +1259,43 @@ export declare const formatUtil: {
     toPlainText(textIncludedHTMLElement?: string): string;
 };
 
+export declare type FormValidationError = ValidationError & {
+    name?: string;
+};
+
+export declare type FormValidationRule = (phase?: ValidationPhase) => Promise<FormValidationError[] | undefined>;
+
+export declare type FormValidator = {
+    /**
+     * Form 안의 모든 FieldValidator 에 대해서 validation 을 수행하고, 그 결과를 리턴한다.
+     */
+    validationResult: () => Promise<FormValidationError[] | undefined>;
+    /**
+     * Form 안의 모든 FieldValidator 에 대해서 validation 을 수행한다.
+     */
+    validate: () => Promise<void>;
+    /**
+     * Form 안의 FieldValidator 를 모두 가져온다.
+     */
+    getFieldValidators: () => FieldValidator<unknown>[];
+    /**
+     * name 속성으로 FieldValidator 를 가져온다.
+     * @param name
+     */
+    getFieldValidator: (name: string) => FieldValidator<unknown> | undefined;
+    /**
+     * validation result 를 모두 제거하고, validation 을 수행하지 않은 상태로 돌아간다.
+     */
+    clear: () => void;
+};
+
+export declare const formValidator: (option: FormValidatorOption) => FormValidator;
+
+export declare type FormValidatorOption = {
+    element?: Ref<HTMLElement | Component | undefined | null>;
+    rules?: FormValidationRule[];
+};
+
 export declare type FunctionProperties<T> = Pick<T, FunctionPropertyNames<T>>;
 
 export declare type FunctionPropertyNames<T> = {
@@ -1256,6 +1335,8 @@ export declare class IllegalAccessError {
 
 export declare const isTooltipDisplayed: () => boolean;
 
+export declare const isValidationFailedError: (err: unknown) => err is ValidationFailedError;
+
 export declare type IterationContext<T> = {
     componentName: string;
     record: T;
@@ -1268,6 +1349,8 @@ export declare type KeyProvider<T> = (item: T) => string | undefined;
 
 export declare type LabelProvider<T> = (item: T) => string | undefined;
 
+export declare const loadFieldValidator: <T>(field: HTMLElement) => FieldValidator<T> | undefined;
+
 export declare type LocaleName = string;
 
 export declare type MenuItem = {
@@ -1492,6 +1575,8 @@ export declare type StoredFile = {
     thumbnailFile?: File;
 };
 
+export declare const storeFieldValidator: <T>(field: HTMLElement, validator: FieldValidator<T>) => void;
+
 export declare type TimeZone = string;
 
 export declare type TooltipEntry = {
@@ -1524,12 +1609,21 @@ export declare const useModalHandle: () => ModalHandle;
 
 export declare const useSavePoint: () => SavePoint | undefined;
 
-declare type ValidationError = {
+export declare const validateField: (field: HTMLElement | string, phase?: ValidationPhase) => Promise<void>;
+
+export declare const validateFields: (fields: (HTMLElement | string)[], phase?: ValidationPhase) => Promise<void>;
+
+export declare type ValidationError = {
     code: string;
     message: string | undefined;
 };
 
-declare type ValidationPhase = 'input' | 'change' | 'blur' | 'form';
+export declare class ValidationFailedError {
+    errors: FormValidationError[];
+    constructor(errors: FormValidationError[]);
+}
+
+export declare type ValidationPhase = 'input' | 'change' | 'blur' | 'form';
 
 /**
  * ```

package/dist/open-bluesea-core.es.js

@@ -1100,6 +1100,22 @@ const storeFieldValidator = (field, validator) => {
   field._bsFieldValidator = validator;
   field.setAttribute("data-bs-field-validator", "");
 };
+const loadFieldValidator = (field) => {
+  return field._bsFieldValidator;
+};
+const findFieldValidatorElements = (element) => {
+  return element?.querySelectorAll("[data-bs-field-validator]");
+};
+const validateField = async (field, phase) => {
+  const element = typeof field === "string" ? document.getElementsByName(field)[0] : field;
+  const validator = element ? loadFieldValidator(element) : void 0;
+  await validator?.validate(phase);
+};
+const validateFields = async (fields, phase) => {
+  for (const field of fields) {
+    await validateField(field, phase);
+  }
+};
 const fieldValidator = (option) => {
   const stringValue = ref();
   const value = ref(option.initialValue);
@@ -5455,6 +5471,60 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
     };
   }
 });
+class ValidationFailedError {
+  constructor(errors) {
+    this.errors = errors;
+  }
+}
+const isValidationFailedError = (err) => {
+  return err instanceof ValidationFailedError;
+};
+const formValidator = (option) => {
+  const getFieldValidators = () => {
+    const element = option.element ? findElement(option.element) : void 0;
+    return Array.from(findFieldValidatorElements(element) || []).map((el) => loadFieldValidator(el)).filter(notNull);
+  };
+  const getFieldValidator = (name) => {
+    return getFieldValidators().find((validator) => validator.getName() === name);
+  };
+  const validationResult = async (phase = "form") => {
+    const validators = getFieldValidators();
+    const invalids = [];
+    for (const validator of validators) {
+      await validator.validate(phase);
+      if (!validator.valid.value) invalids.push(validator);
+    }
+    if (invalids.length > 0) {
+      return invalids.flatMap((invalid) => invalid.errors.value.map((error) => ({ name: invalid.getName(), ...error })));
+    }
+    const errors = [];
+    if (option.rules) {
+      for (const rule of option.rules) {
+        const result = await rule(phase);
+        result?.forEach((error) => errors.push(error));
+      }
+    }
+    return errors.length > 0 ? errors : void 0;
+  };
+  const validate = async (phase = "form") => {
+    const result = await validationResult(phase);
+    if (result) {
+      throw new ValidationFailedError(result);
+    }
+  };
+  const clear = () => {
+    getFieldValidators().forEach((validator) => {
+      validator.clearErrors();
+    });
+  };
+  return {
+    validationResult,
+    validate,
+    getFieldValidators,
+    getFieldValidator,
+    clear
+  };
+};
 class IllegalAccessError {
 }
 export {
@@ -5494,6 +5564,7 @@ export {
   IllegalAccessError,
   NAMED_COLORS,
   SavePointImpl,
+  ValidationFailedError,
   alarmEntries,
   cancelProvidedSavePoint,
   closeAlarm,
@@ -5505,14 +5576,23 @@ export {
   defaultLabelProvider,
   emptyKeyProvider,
   emptyLabelProvider,
+  executeBetweenLengthValidation,
+  executeBetweenValueValidation,
+  executeDateRangeValidation,
+  executeFieldValidationRule,
   executeKeyProviderOrDefault,
   executeLabelProviderOrDefault,
+  executeRegExpValidation,
+  executeRequiredValidation,
+  fieldValidator,
   findElement,
+  findFieldValidatorElements,
   findFirstFocusableElement,
   findInputComponents,
   findLastFocusableElement,
   focusFirstElement,
   focusLastElement,
+  formValidator,
   formatUtil,
   getComponentRootElement,
   getIcon,
@@ -5520,6 +5600,8 @@ export {
   hideLoading,
   hideTooltip,
   isTooltipDisplayed,
+  isValidationFailedError,
+  loadFieldValidator,
   modalHandleKey,
   modalPluginKey,
   notNull,
@@ -5534,6 +5616,7 @@ export {
   showLoadingIcon,
   showNotification,
   showTooltip,
+  storeFieldValidator,
   tooltipEntry,
   tryUntil,
   useBlueseaConfig,
@@ -5547,6 +5630,8 @@ export {
   VFocusLoop as vFocusLoop,
   vFocusOnLoad,
   vTooltip,
+  validateField,
+  validateFields,
   waitDuring,
   waitUntil,
   withLoading

package/dist/open-bluesea-core.umd.js

@@ -1102,6 +1102,22 @@
     field._bsFieldValidator = validator;
     field.setAttribute("data-bs-field-validator", "");
   };
+  const loadFieldValidator = (field) => {
+    return field._bsFieldValidator;
+  };
+  const findFieldValidatorElements = (element) => {
+    return element?.querySelectorAll("[data-bs-field-validator]");
+  };
+  const validateField = async (field, phase) => {
+    const element = typeof field === "string" ? document.getElementsByName(field)[0] : field;
+    const validator = element ? loadFieldValidator(element) : void 0;
+    await validator?.validate(phase);
+  };
+  const validateFields = async (fields, phase) => {
+    for (const field of fields) {
+      await validateField(field, phase);
+    }
+  };
   const fieldValidator = (option) => {
     const stringValue = vue.ref();
     const value = vue.ref(option.initialValue);
@@ -5465,6 +5481,60 @@
       };
     }
   });
+  class ValidationFailedError {
+    constructor(errors) {
+      this.errors = errors;
+    }
+  }
+  const isValidationFailedError = (err) => {
+    return err instanceof ValidationFailedError;
+  };
+  const formValidator = (option) => {
+    const getFieldValidators = () => {
+      const element = option.element ? findElement(option.element) : void 0;
+      return Array.from(findFieldValidatorElements(element) || []).map((el) => loadFieldValidator(el)).filter(notNull);
+    };
+    const getFieldValidator = (name) => {
+      return getFieldValidators().find((validator) => validator.getName() === name);
+    };
+    const validationResult = async (phase = "form") => {
+      const validators = getFieldValidators();
+      const invalids = [];
+      for (const validator of validators) {
+        await validator.validate(phase);
+        if (!validator.valid.value) invalids.push(validator);
+      }
+      if (invalids.length > 0) {
+        return invalids.flatMap((invalid) => invalid.errors.value.map((error) => ({ name: invalid.getName(), ...error })));
+      }
+      const errors = [];
+      if (option.rules) {
+        for (const rule of option.rules) {
+          const result = await rule(phase);
+          result?.forEach((error) => errors.push(error));
+        }
+      }
+      return errors.length > 0 ? errors : void 0;
+    };
+    const validate = async (phase = "form") => {
+      const result = await validationResult(phase);
+      if (result) {
+        throw new ValidationFailedError(result);
+      }
+    };
+    const clear = () => {
+      getFieldValidators().forEach((validator) => {
+        validator.clearErrors();
+      });
+    };
+    return {
+      validationResult,
+      validate,
+      getFieldValidators,
+      getFieldValidator,
+      clear
+    };
+  };
   class IllegalAccessError {
   }
   exports2.BSAlertModal = _sfc_main$4;
@@ -5503,6 +5573,7 @@
   exports2.IllegalAccessError = IllegalAccessError;
   exports2.NAMED_COLORS = NAMED_COLORS;
   exports2.SavePointImpl = SavePointImpl;
+  exports2.ValidationFailedError = ValidationFailedError;
   exports2.alarmEntries = alarmEntries;
   exports2.cancelProvidedSavePoint = cancelProvidedSavePoint;
   exports2.closeAlarm = closeAlarm;
@@ -5514,14 +5585,23 @@
   exports2.defaultLabelProvider = defaultLabelProvider;
   exports2.emptyKeyProvider = emptyKeyProvider;
   exports2.emptyLabelProvider = emptyLabelProvider;
+  exports2.executeBetweenLengthValidation = executeBetweenLengthValidation;
+  exports2.executeBetweenValueValidation = executeBetweenValueValidation;
+  exports2.executeDateRangeValidation = executeDateRangeValidation;
+  exports2.executeFieldValidationRule = executeFieldValidationRule;
   exports2.executeKeyProviderOrDefault = executeKeyProviderOrDefault;
   exports2.executeLabelProviderOrDefault = executeLabelProviderOrDefault;
+  exports2.executeRegExpValidation = executeRegExpValidation;
+  exports2.executeRequiredValidation = executeRequiredValidation;
+  exports2.fieldValidator = fieldValidator;
   exports2.findElement = findElement;
+  exports2.findFieldValidatorElements = findFieldValidatorElements;
   exports2.findFirstFocusableElement = findFirstFocusableElement;
   exports2.findInputComponents = findInputComponents;
   exports2.findLastFocusableElement = findLastFocusableElement;
   exports2.focusFirstElement = focusFirstElement;
   exports2.focusLastElement = focusLastElement;
+  exports2.formValidator = formValidator;
   exports2.formatUtil = formatUtil;
   exports2.getComponentRootElement = getComponentRootElement;
   exports2.getIcon = getIcon;
@@ -5529,6 +5609,8 @@
   exports2.hideLoading = hideLoading;
   exports2.hideTooltip = hideTooltip;
   exports2.isTooltipDisplayed = isTooltipDisplayed;
+  exports2.isValidationFailedError = isValidationFailedError;
+  exports2.loadFieldValidator = loadFieldValidator;
   exports2.modalHandleKey = modalHandleKey;
   exports2.modalPluginKey = modalPluginKey;
   exports2.notNull = notNull;
@@ -5543,6 +5625,7 @@
   exports2.showLoadingIcon = showLoadingIcon;
   exports2.showNotification = showNotification;
   exports2.showTooltip = showTooltip;
+  exports2.storeFieldValidator = storeFieldValidator;
   exports2.tooltipEntry = tooltipEntry;
   exports2.tryUntil = tryUntil;
   exports2.useBlueseaConfig = useBlueseaConfig;
@@ -5556,6 +5639,8 @@
   exports2.vFocusLoop = VFocusLoop;
   exports2.vFocusOnLoad = vFocusOnLoad;
   exports2.vTooltip = vTooltip;
+  exports2.validateField = validateField;
+  exports2.validateFields = validateFields;
   exports2.waitDuring = waitDuring;
   exports2.waitUntil = waitUntil;
   exports2.withLoading = withLoading;

package/package.json

@@ -3,7 +3,7 @@
   "description": "Vue UI Library for Management Console.",
   "license": "Proprietary",
   "private": false,
-  "version": "1.0.0-alpha.10",
+  "version": "1.0.0-alpha.11",
   "type": "module",
   "engines": {
     "node": ">= 24.3.0"