nuxt-ui-tools 1.11.2 → 1.13.0

package/dist/runtime/spreadsheet/utils/validation/core.js

@@ -1,211 +0,0 @@
-import { useUiToolsLocale } from "#ui-tools/i18n";
-import { isBoolean, isFunction } from "#ui-tools/shared/utils/predicate";
-import { isNullish } from "../../../shared/utils/predicate.js";
-import { isSpreadsheetRecord } from "../object.js";
-function isSpreadsheetMessageResolver(value) {
-  return isFunction(value);
-}
-function isSpreadsheetRuleFactory(value) {
-  return isFunction(value);
-}
-function resolveSpreadsheetMessage(value, context) {
-  if (isSpreadsheetMessageResolver(value)) {
-    return value(context);
-  }
-  return String(value);
-}
-function isSpreadsheetRuleOverride(value) {
-  return isSpreadsheetRecord(value) && "message" in value;
-}
-function resolveSpreadsheetRuleFactoryInput(input) {
-  const lastItem = input.at(-1);
-  if (!isSpreadsheetRuleOverride(lastItem)) {
-    return {
-      overrides: void 0,
-      params: input
-    };
-  }
-  return {
-    overrides: lastItem,
-    params: input.slice(0, -1)
-  };
-}
-function createSpreadsheetRuleInstance(options) {
-  return {
-    $rule: true,
-    flags: options.flags,
-    level: "error",
-    name: options.name,
-    validate(value) {
-      const messageResolver = options.message;
-      const rawResult = options.validator(value, ...options.params);
-      if (isBoolean(rawResult)) {
-        if (rawResult) {
-          return {
-            $message: null,
-            $meta: Object.fromEntries([]),
-            $valid: true
-          };
-        }
-        return {
-          $message: resolveSpreadsheetMessage(messageResolver, {
-            $valid: false,
-            params: options.params,
-            value
-          }),
-          $meta: Object.fromEntries([]),
-          $valid: false
-        };
-      }
-      const metaEntries = Object.entries(rawResult).filter(([key]) => key !== "$valid");
-      const result = {
-        $message: null,
-        $meta: Object.fromEntries(metaEntries),
-        $valid: rawResult.$valid
-      };
-      if (result.$valid) {
-        return {
-          $message: null,
-          $meta: result.$meta,
-          $valid: true
-        };
-      }
-      return {
-        ...result,
-        $message: resolveSpreadsheetMessage(messageResolver, {
-          params: options.params,
-          value,
-          ...rawResult
-        })
-      };
-    }
-  };
-}
-function createRule(options) {
-  return (...input) => {
-    const { params, overrides } = resolveSpreadsheetRuleFactoryInput(input);
-    return createSpreadsheetRuleInstance({
-      flags: options.flags,
-      message: overrides?.message ?? options.message,
-      name: options.name,
-      params,
-      validator: options.validator
-    });
-  };
-}
-function validate(options) {
-  const createInlineRule = createRule({
-    message: options.message,
-    name: options.name,
-    validator: options.validator
-  });
-  return createInlineRule();
-}
-function createNumericValueGuard(value) {
-  return !Number.isNaN(value) && Number.isFinite(value);
-}
-function createSpreadsheetRuleBuilder() {
-  const { t } = useUiToolsLocale();
-  return {
-    between: createRule({
-      message: ({ value, params: [min, max] }) => t("spreadsheet.validation.between", { max, min, value }),
-      name: "between",
-      validator: (value, min, max) => ({
-        $valid: createNumericValueGuard(value) && value >= min && value <= max,
-        max,
-        min
-      })
-    }),
-    max: createRule({
-      message: ({ value, params: [max] }) => t("spreadsheet.validation.max", { max, value }),
-      name: "max",
-      validator: (value, max) => ({
-        $valid: createNumericValueGuard(value) && value <= max,
-        max
-      })
-    }),
-    maxLength: createRule({
-      message: ({ value, params: [max] }) => t("spreadsheet.validation.maxLength", { length: value.length, max }),
-      name: "maxLength",
-      validator: (value, max) => ({
-        $valid: value.length <= max,
-        max
-      })
-    }),
-    min: createRule({
-      message: ({ value, params: [min] }) => t("spreadsheet.validation.min", { min, value }),
-      name: "min",
-      validator: (value, min) => ({
-        $valid: createNumericValueGuard(value) && value >= min,
-        min
-      })
-    }),
-    minLength: createRule({
-      message: ({ value, params: [min] }) => t("spreadsheet.validation.minLength", { length: value.length, min }),
-      name: "minLength",
-      validator: (value, min) => ({
-        $valid: value.length >= min,
-        min
-      })
-    }),
-    number: createRule({
-      message: () => t("spreadsheet.validation.number"),
-      name: "number",
-      validator: (value) => createNumericValueGuard(value)
-    }),
-    oneOf(values, overrides) {
-      const ruleFactory = createRule({
-        message: ({ value, params: [allowedValues] }) => t("spreadsheet.validation.oneOf", {
-          value: String(value),
-          values: allowedValues.map(String).join(", ")
-        }),
-        name: "oneOf",
-        validator: (value, allowedValues) => ({
-          $valid: allowedValues.includes(value),
-          values: allowedValues
-        })
-      });
-      return ruleFactory(values, overrides);
-    },
-    required: createRule({
-      flags: { required: true },
-      message: () => t("spreadsheet.validation.required"),
-      name: "required",
-      validator: (value) => !isNullish(value) && value !== ""
-    }),
-    validate
-  };
-}
-export const createSheetRule = createRule;
-export function resolveSpreadsheetRules(rules) {
-  if (!rules) {
-    return [];
-  }
-  if (isSpreadsheetRuleFactory(rules)) {
-    return rules(createSpreadsheetRuleBuilder());
-  }
-  return rules;
-}
-export function resolveSpreadsheetRelationRules(params) {
-  return params.rules(createSpreadsheetRuleBuilder(), params.row);
-}
-export function executeSpreadsheetRules(params) {
-  const rules = resolveSpreadsheetRules(params.rules);
-  if (!rules.length) {
-    return [];
-  }
-  return rules.flatMap((rule, index) => {
-    const result = rule.validate(params.value);
-    if (result.$valid) {
-      return [];
-    }
-    return [
-      {
-        code: rule.name ?? `rule.${index}`,
-        level: rule.level,
-        message: result.$message ?? "",
-        ruleKey: rule.name
-      }
-    ];
-  });
-}

package/dist/runtime/spreadsheet/utils/validation/index.d.ts

@@ -1 +0,0 @@
-export * from './core.js';

package/dist/runtime/spreadsheet/utils/validation/index.js

@@ -1 +0,0 @@
-export * from "./core.js";