taro-bluetooth-print 2.9.0 → 2.9.2

package/src/utils/validators/array.ts

@@ -0,0 +1,95 @@
+/**
+ * Array validation
+ */
+
+import { ValidationCodes, type ValidationError, type ValidationResult } from './types';
+
+/**
+ * Validate an array of items
+ *
+ * @param items - Array to validate
+ * @param itemValidator - Validator function for each item
+ * @param options - Array validation options
+ * @returns Validation result
+ *
+ * @example
+ * ```typescript
+ * const result = validateArray(items, item => validatePrintJob(item, schema), { minItems: 1, maxItems: 100 });
+ * ```
+ */
+export function validateArray<T>(
+  items: unknown,
+  itemValidator: (item: T, index: number) => ValidationResult,
+  options?: {
+    required?: boolean;
+    minItems?: number;
+    maxItems?: number;
+  }
+): ValidationResult {
+  const errors: ValidationError[] = [];
+  const warnings: ValidationError[] = [];
+
+  if (items === undefined || items === null) {
+    if (options?.required) {
+      errors.push({
+        field: 'array',
+        message: 'Array is required',
+        code: ValidationCodes.REQUIRED,
+      });
+    }
+    return { valid: errors.length === 0, errors, warnings };
+  }
+
+  if (!Array.isArray(items)) {
+    errors.push({
+      field: 'array',
+      message: 'Expected an array',
+      code: ValidationCodes.INVALID_TYPE,
+      value: typeof items,
+    });
+    return { valid: false, errors, warnings };
+  }
+
+  if (options?.minItems !== undefined && items.length < options.minItems) {
+    errors.push({
+      field: 'array',
+      message: `Array must have at least ${options.minItems} items`,
+      code: ValidationCodes.ARRAY_TOO_SHORT,
+      value: items.length,
+    });
+  }
+
+  if (options?.maxItems !== undefined && items.length > options.maxItems) {
+    errors.push({
+      field: 'array',
+      message: `Array must have at most ${options.maxItems} items`,
+      code: ValidationCodes.ARRAY_TOO_LONG,
+      value: items.length,
+    });
+  }
+
+  // Validate each item
+  for (let i = 0; i < items.length; i++) {
+    const itemResult = itemValidator(items[i] as T, i);
+    errors.push(
+      ...itemResult.errors.map(err => ({
+        ...err,
+        field: `${err.field}[${i}]`,
+      }))
+    );
+    if (itemResult.warnings) {
+      warnings.push(
+        ...itemResult.warnings.map(w => ({
+          ...w,
+          field: `${w.field}[${i}]`,
+        }))
+      );
+    }
+  }
+
+  return {
+    valid: errors.length === 0,
+    errors,
+    ...(warnings.length > 0 ? { warnings } : {}),
+  };
+}

package/src/utils/validators/buffer.ts

@@ -0,0 +1,81 @@
+/**
+ * ArrayBuffer validation
+ */
+
+import { ValidationCodes, type ValidationError, type ValidationResult } from './types';
+
+/**
+ * Validate an ArrayBuffer
+ *
+ * @param buffer - Buffer to validate
+ * @param options - Validation options
+ * @returns Validation result
+ *
+ * @example
+ * ```typescript
+ * const result = isValidBuffer(data, { minSize: 1, maxSize: 1024 * 1024 });
+ * ```
+ */
+export function isValidBuffer(
+  buffer: unknown,
+  options?: {
+    minSize?: number;
+    maxSize?: number;
+    required?: boolean;
+  }
+): ValidationResult {
+  const errors: ValidationError[] = [];
+  const warnings: ValidationError[] = [];
+
+  if (!(buffer instanceof ArrayBuffer)) {
+    errors.push({
+      field: 'buffer',
+      message: 'Expected an ArrayBuffer',
+      code: ValidationCodes.INVALID_TYPE,
+      value: typeof buffer,
+    });
+    return {
+      valid: false,
+      errors,
+      ...(warnings.length > 0 ? { warnings } : {}),
+    };
+  }
+
+  const byteLength = buffer.byteLength;
+  // When required is true without explicit minSize, treat empty buffer as TOO_SHORT
+  const effectiveMinSize =
+    options?.required && options?.minSize === undefined ? 1 : options?.minSize;
+
+  if (effectiveMinSize !== undefined && byteLength < effectiveMinSize) {
+    errors.push({
+      field: 'buffer',
+      message: `Buffer must be at least ${effectiveMinSize} bytes`,
+      code: ValidationCodes.TOO_SHORT,
+      value: byteLength,
+    });
+  }
+
+  if (options?.maxSize !== undefined && byteLength > options.maxSize) {
+    errors.push({
+      field: 'buffer',
+      message: `Buffer exceeds maximum size of ${options.maxSize} bytes`,
+      code: ValidationCodes.TOO_LONG,
+      value: byteLength,
+    });
+  }
+
+  if (byteLength === 0) {
+    warnings.push({
+      field: 'buffer',
+      message: 'Buffer is empty',
+      code: ValidationCodes.EMPTY_ARRAY,
+      value: byteLength,
+    });
+  }
+
+  return {
+    valid: errors.length === 0,
+    errors,
+    ...(warnings.length > 0 ? { warnings } : {}),
+  };
+}

package/src/utils/validators/chain.ts

@@ -0,0 +1,181 @@
+/**
+ * Chainable validation helper
+ */
+
+import { ValidationCodes, type ValidationError, type ValidationResult } from './types';
+
+export interface ChainableValidator {
+  addError(message: string, code: string): ChainableValidator;
+  required(): ChainableValidator;
+  string(): ChainableValidator;
+  number(): ChainableValidator;
+  integer(): ChainableValidator;
+  range(min: number, max: number): ChainableValidator;
+  length(min: number, max: number): ChainableValidator;
+  pattern(regex: RegExp, message?: string): ChainableValidator;
+  oneOf<T>(values: readonly T[], message?: string): ChainableValidator;
+  result(): ValidationResult;
+}
+
+/**
+ * Create a chainable validation helper
+ *
+ * @param value - Value to validate
+ * @param field - Field name
+ * @returns Chainable validator
+ *
+ * @example
+ * ```typescript
+ * const result = check(value, 'timeout')
+ *   .required()
+ *   .number()
+ *   .range(0, 30000)
+ *   .integer()
+ *   .result();
+ * ```
+ */
+export function check(value: unknown, field: string): ChainableValidator {
+  const errors: ValidationError[] = [];
+
+  const self: ChainableValidator = {
+    /** Add error manually */
+    addError(message: string, code: string) {
+      errors.push({ field, message, code, value });
+      return this;
+    },
+
+    /** Validate required */
+    required() {
+      if (value === undefined || value === null || value === '') {
+        errors.push({
+          field,
+          message: `${field} is required`,
+          code: ValidationCodes.REQUIRED,
+          value,
+        });
+      }
+      return this;
+    },
+
+    /** Validate type is string */
+    string() {
+      if (value !== undefined && value !== null && typeof value !== 'string') {
+        errors.push({
+          field,
+          message: `${field} must be a string`,
+          code: ValidationCodes.INVALID_TYPE,
+          value: typeof value,
+        });
+      }
+      return this;
+    },
+
+    /** Validate type is number */
+    number() {
+      if (value !== undefined && value !== null && typeof value !== 'number') {
+        errors.push({
+          field,
+          message: `${field} must be a number`,
+          code: ValidationCodes.INVALID_TYPE,
+          value: typeof value,
+        });
+      }
+      return this;
+    },
+
+    /** Validate is integer */
+    integer() {
+      if (typeof value === 'number' && !Number.isInteger(value)) {
+        errors.push({
+          field,
+          message: `${field} must be an integer`,
+          code: ValidationCodes.INVALID_TYPE,
+          value,
+        });
+      }
+      return this;
+    },
+
+    /** Validate range */
+    range(min: number, max: number) {
+      if (typeof value === 'number') {
+        if (value < min) {
+          errors.push({
+            field,
+            message: `${field} must be at least ${min}`,
+            code: ValidationCodes.OUT_OF_RANGE,
+            value,
+          });
+        }
+        if (value > max) {
+          errors.push({
+            field,
+            message: `${field} must be at most ${max}`,
+            code: ValidationCodes.OUT_OF_RANGE,
+            value,
+          });
+        }
+      }
+      return this;
+    },
+
+    /** Validate string length */
+    length(min: number, max: number) {
+      if (typeof value === 'string') {
+        if (value.length < min) {
+          errors.push({
+            field,
+            message: `${field} must be at least ${min} characters`,
+            code: ValidationCodes.TOO_SHORT,
+            value,
+          });
+        }
+        if (value.length > max) {
+          errors.push({
+            field,
+            message: `${field} must be at most ${max} characters`,
+            code: ValidationCodes.TOO_LONG,
+            value,
+          });
+        }
+      }
+      return this;
+    },
+
+    /** Validate matches pattern */
+    pattern(regex: RegExp, message?: string) {
+      if (typeof value === 'string' && !regex.test(value)) {
+        errors.push({
+          field,
+          message: message ?? `${field} format is invalid`,
+          code: ValidationCodes.PATTERN_MISMATCH,
+          value,
+        });
+      }
+      return this;
+    },
+
+    /** Validate is one of values */
+    oneOf<T>(values: readonly T[], message?: string) {
+      if (!values.includes(value as T)) {
+        errors.push({
+          field,
+          message: message ?? `${field} must be one of: ${values.join(', ')}`,
+          code: ValidationCodes.INVALID_ENUM,
+          value,
+        });
+      }
+      return this;
+    },
+
+    /** Get validation result */
+    result() {
+      return {
+        valid: errors.length === 0,
+        errors,
+      };
+    },
+  };
+
+  return self;
+}

package/src/utils/validators/common.ts

@@ -0,0 +1,216 @@
+/**
+ * Common validation helpers
+ */
+
+import { ValidationCodes, type ValidationError } from './types';
+
+/**
+ * Common validation rules
+ */
+export const CommonValidators = {
+  /** Required string (non-empty) */
+  requiredString: (field: string, value: unknown): ValidationError | null => {
+    if (value === undefined || value === null || value === '') {
+      return {
+        field,
+        message: `${field} is required`,
+        code: ValidationCodes.REQUIRED,
+        value,
+      };
+    }
+    if (typeof value !== 'string') {
+      return {
+        field,
+        message: `${field} must be a string`,
+        code: ValidationCodes.INVALID_TYPE,
+        value,
+      };
+    }
+    return null;
+  },
+
+  /** Positive number */
+  positiveNumber: (field: string, value: unknown): ValidationError | null => {
+    if (typeof value !== 'number') {
+      return {
+        field,
+        message: `${field} must be a number`,
+        code: ValidationCodes.INVALID_TYPE,
+        value,
+      };
+    }
+    if (isNaN(value)) {
+      return {
+        field,
+        message: `${field} must be a valid number`,
+        code: ValidationCodes.NOT_A_NUMBER,
+        value,
+      };
+    }
+    if (!isFinite(value)) {
+      return {
+        field,
+        message: `${field} must be a finite number`,
+        code: ValidationCodes.INFINITY_VALUE,
+        value,
+      };
+    }
+    if (value <= 0) {
+      return {
+        field,
+        message: `${field} must be positive`,
+        code: ValidationCodes.NEGATIVE_VALUE,
+        value,
+      };
+    }
+    return null;
+  },
+
+  /** Non-negative number */
+  nonNegativeNumber: (field: string, value: unknown): ValidationError | null => {
+    if (typeof value !== 'number') {
+      return {
+        field,
+        message: `${field} must be a number`,
+        code: ValidationCodes.INVALID_TYPE,
+        value,
+      };
+    }
+    if (isNaN(value)) {
+      return {
+        field,
+        message: `${field} must be a valid number`,
+        code: ValidationCodes.NOT_A_NUMBER,
+        value,
+      };
+    }
+    if (value < 0) {
+      return {
+        field,
+        message: `${field} cannot be negative`,
+        code: ValidationCodes.NEGATIVE_VALUE,
+        value,
+      };
+    }
+    return null;
+  },
+
+  /** Array with items */
+  nonEmptyArray: (field: string, value: unknown): ValidationError | null => {
+    if (!Array.isArray(value)) {
+      return {
+        field,
+        message: `${field} must be an array`,
+        code: ValidationCodes.INVALID_TYPE,
+        value,
+      };
+    }
+    if (value.length === 0) {
+      return {
+        field,
+        message: `${field} cannot be empty`,
+        code: ValidationCodes.EMPTY_ARRAY,
+        value,
+      };
+    }
+    return null;
+  },
+
+  /** In range */
+  inRange: (field: string, value: unknown, min: number, max: number): ValidationError | null => {
+    if (typeof value !== 'number') {
+      return {
+        field,
+        message: `${field} must be a number`,
+        code: ValidationCodes.INVALID_TYPE,
+        value,
+      };
+    }
+    if (value < min || value > max) {
+      return {
+        field,
+        message: `${field} must be between ${min} and ${max}`,
+        code: ValidationCodes.OUT_OF_RANGE,
+        value,
+      };
+    }
+    return null;
+  },
+
+  /** String length */
+  stringLength: (
+    field: string,
+    value: unknown,
+    min: number,
+    max: number
+  ): ValidationError | null => {
+    if (typeof value !== 'string') {
+      return {
+        field,
+        message: `${field} must be a string`,
+        code: ValidationCodes.INVALID_TYPE,
+        value,
+      };
+    }
+    if (value.length < min) {
+      return {
+        field,
+        message: `${field} must be at least ${min} characters`,
+        code: ValidationCodes.TOO_SHORT,
+        value,
+      };
+    }
+    if (value.length > max) {
+      return {
+        field,
+        message: `${field} must be at most ${max} characters`,
+        code: ValidationCodes.TOO_LONG,
+        value,
+      };
+    }
+    return null;
+  },
+
+  /** Matches pattern */
+  matchesPattern: (
+    field: string,
+    value: unknown,
+    pattern: RegExp,
+    message?: string
+  ): ValidationError | null => {
+    if (typeof value !== 'string') {
+      return {
+        field,
+        message: `${field} must be a string`,
+        code: ValidationCodes.INVALID_TYPE,
+        value,
+      };
+    }
+    if (!pattern.test(value)) {
+      return {
+        field,
+        message: message ?? `${field} format is invalid`,
+        code: ValidationCodes.PATTERN_MISMATCH,
+        value,
+      };
+    }
+    return null;
+  },
+
+  /** Is one of enum values */
+  isEnum: <T extends string>(
+    field: string,
+    value: unknown,
+    enumValues: readonly T[]
+  ): ValidationError | null => {
+    if (!enumValues.includes(value as T)) {
+      return {
+        field,
+        message: `${field} must be one of: ${enumValues.join(', ')}`,
+        code: ValidationCodes.INVALID_ENUM,
+        value,
+      };
+    }
+    return null;
+  },
+};

package/src/utils/validators/number.ts

@@ -0,0 +1,101 @@
+/**
+ * Numeric range validation
+ */
+
+import { ValidationCodes, type ValidationError, type ValidationResult } from './types';
+
+/**
+ * Validate numeric range
+ *
+ * @param value - Value to validate
+ * @param field - Field name for error messages
+ * @param options - Range options
+ * @returns Validation result
+ *
+ * @example
+ * ```typescript
+ * const result = validateRange(value, 'timeout', { min: 0, max: 30000, integer: true });
+ * ```
+ */
+export function validateRange(
+  value: unknown,
+  field: string,
+  options?: {
+    required?: boolean;
+    min?: number;
+    max?: number;
+    integer?: boolean;
+  }
+): ValidationResult {
+  const errors: ValidationError[] = [];
+
+  if (value === undefined || value === null) {
+    if (options?.required) {
+      errors.push({
+        field,
+        message: `${field} is required`,
+        code: ValidationCodes.REQUIRED,
+      });
+    }
+    return { valid: errors.length === 0, errors };
+  }
+
+  if (typeof value !== 'number') {
+    errors.push({
+      field,
+      message: `${field} must be a number`,
+      code: ValidationCodes.INVALID_TYPE,
+      value: typeof value,
+    });
+    return { valid: false, errors };
+  }
+
+  if (isNaN(value)) {
+    errors.push({
+      field,
+      message: `${field} must be a valid number`,
+      code: ValidationCodes.NOT_A_NUMBER,
+      value,
+    });
+    return { valid: false, errors };
+  }
+
+  if (!isFinite(value)) {
+    errors.push({
+      field,
+      message: `${field} must be a finite number`,
+      code: ValidationCodes.INFINITY_VALUE,
+      value,
+    });
+    return { valid: false, errors };
+  }
+
+  if (options?.integer && !Number.isInteger(value)) {
+    errors.push({
+      field,
+      message: `${field} must be an integer`,
+      code: ValidationCodes.INVALID_TYPE,
+      value,
+    });
+  }
+
+  if (options?.min !== undefined && value < options.min) {
+    errors.push({
+      field,
+      message: `${field} must be at least ${options.min}`,
+      code: ValidationCodes.OUT_OF_RANGE,
+      value,
+    });
+  }
+
+  if (options?.max !== undefined && value > options.max) {
+    errors.push({
+      field,
+      message: `${field} must be at most ${options.max}`,
+      code: ValidationCodes.OUT_OF_RANGE,
+      value,
+    });
+  }
+
+  return { valid: errors.length === 0, errors };
+}