function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
/**
 * 类型验证工具函数
 * 用于验证默认值是否符合指定的字段类型
 */

/**
 * 验证字符串类型
 */
var validateString = function validateString(value) {
  if (value === null || value === undefined || value === '') {
    return {
      isValid: true
    };
  }
  if (typeof value === 'string') {
    return {
      isValid: true
    };
  }
  return {
    isValid: false,
    error: '默认值必须是字符串类型'
  };
};

/**
 * 验证整数类型
 */
var validateInteger = function validateInteger(value) {
  if (value === null || value === undefined || value === '') {
    return {
      isValid: true
    };
  }

  // 如果是数字，检查是否为整数
  if (typeof value === 'number') {
    if (!Number.isInteger(value)) {
      return {
        isValid: false,
        error: '默认值必须是整数'
      };
    }
    return {
      isValid: true
    };
  }

  // 如果是字符串，尝试转换
  if (typeof value === 'string') {
    var trimmed = value.trim();
    if (trimmed === '') {
      return {
        isValid: true
      };
    }
    var num = Number(trimmed);
    if (isNaN(num) || !Number.isInteger(num)) {
      return {
        isValid: false,
        error: '默认值必须是有效的整数'
      };
    }
    return {
      isValid: true
    };
  }
  return {
    isValid: false,
    error: '默认值必须是有效的整数'
  };
};

/**
 * 验证浮点数类型
 */
var validateFloat = function validateFloat(value) {
  if (value === null || value === undefined || value === '') {
    return {
      isValid: true
    };
  }

  // 如果是数字，检查是否有效
  if (typeof value === 'number') {
    if (!isFinite(value)) {
      return {
        isValid: false,
        error: '默认值必须是有效的数字'
      };
    }
    return {
      isValid: true
    };
  }

  // 如果是字符串，尝试转换
  if (typeof value === 'string') {
    var trimmed = value.trim();
    if (trimmed === '') {
      return {
        isValid: true
      };
    }
    var num = Number(trimmed);
    if (isNaN(num) || !isFinite(num)) {
      return {
        isValid: false,
        error: '默认值必须是有效的数字'
      };
    }
    return {
      isValid: true
    };
  }
  return {
    isValid: false,
    error: '默认值必须是有效的数字'
  };
};

/**
 * 验证布尔类型
 */
var validateBoolean = function validateBoolean(value) {
  if (value === null || value === undefined || value === '') {
    return {
      isValid: true
    };
  }

  // 如果是字符串，只接受 'true' 或 'false'
  if (typeof value === 'string') {
    var trimmed = value.trim().toLowerCase();
    if (trimmed === '') {
      return {
        isValid: true
      };
    }
    if (trimmed !== 'true' && trimmed !== 'false') {
      return {
        isValid: false,
        error: '默认值必须是 true 或 false'
      };
    }
    return {
      isValid: true
    };
  }

  // 如果是布尔类型
  if (typeof value === 'boolean') {
    return {
      isValid: true
    };
  }
  return {
    isValid: false,
    error: '默认值必须是 true 或 false'
  };
};

/**
 * 验证数组类型（JSON对象/数组）
 */
var validateArray = function validateArray(value) {
  if (value === null || value === undefined || value === '') {
    return {
      isValid: true
    };
  }

  // 如果是字符串，尝试解析为JSON
  if (typeof value === 'string') {
    var trimmed = value.trim();
    if (trimmed === '') {
      return {
        isValid: true
      };
    }
    try {
      var parsed = JSON.parse(trimmed);
      // 检查解析后的值是否为对象或数组
      if (_typeof(parsed) !== 'object' || parsed === null) {
        return {
          isValid: false,
          error: '默认值必须是有效的JSON对象或数组'
        };
      }
      return {
        isValid: true
      };
    } catch (error) {
      return {
        isValid: false,
        error: '默认值必须是有效的JSON对象或数组'
      };
    }
  }

  // 如果是对象或数组
  if (_typeof(value) === 'object' && value !== null) {
    return {
      isValid: true
    };
  }
  return {
    isValid: false,
    error: '默认值必须是有效的JSON对象或数组'
  };
};

/**
 * 根据字段类型验证默认值
 */
export var validateDefaultValue = function validateDefaultValue(fieldType, defaultValue) {
  if (!fieldType) {
    return {
      isValid: false,
      error: '字段类型不能为空'
    };
  }
  switch (fieldType.toLowerCase()) {
    case 'string':
      return validateString(defaultValue);
    case 'integer':
      return validateInteger(defaultValue);
    case 'float':
      return validateFloat(defaultValue);
    case 'boolean':
      return validateBoolean(defaultValue);
    case 'array':
      return validateArray(defaultValue);
    default:
      return {
        isValid: false,
        error: "\u4E0D\u652F\u6301\u7684\u5B57\u6BB5\u7C7B\u578B: ".concat(fieldType)
      };
  }
};

/**
 * 解析默认值为对应的类型
 */
export var parseDefaultValue = function parseDefaultValue(fieldType, defaultValue) {
  if (defaultValue === null || defaultValue === undefined || defaultValue === '') {
    return null;
  }
  switch (fieldType.toLowerCase()) {
    case 'string':
      return String(defaultValue);
    case 'integer':
      if (typeof defaultValue === 'string') {
        var trimmed = defaultValue.trim();
        if (trimmed === '') return null;
        return parseInt(trimmed, 10);
      }
      return defaultValue;
    case 'float':
      if (typeof defaultValue === 'string') {
        var _trimmed = defaultValue.trim();
        if (_trimmed === '') return null;
        return parseFloat(_trimmed);
      }
      return defaultValue;
    case 'boolean':
      if (typeof defaultValue === 'string') {
        var _trimmed2 = defaultValue.trim().toLowerCase();
        if (_trimmed2 === '') return null;
        return _trimmed2 === 'true';
      }
      return Boolean(defaultValue);
    case 'array':
      if (typeof defaultValue === 'string') {
        var _trimmed3 = defaultValue.trim();
        if (_trimmed3 === '') return null;
        return JSON.parse(_trimmed3);
      }
      return defaultValue;
    default:
      return defaultValue;
  }
};