taro-bluetooth-print 2.9.0 → 2.9.2

package/dist/types/utils/outputLimiter.d.ts

@@ -0,0 +1,87 @@
+/**
+ * 输出限制工具 - 防止响应被截断
+ * 用于处理大量数据输出时的截断问题
+ */
+/**
+ * 截断配置选项
+ */
+export interface TruncateOptions {
+    /** 最大长度限制 */
+    maxLength?: number;
+    /** 截断后添加的后缀 */
+    suffix?: string;
+    /** 是否保留开头部分 */
+    preserveHead?: boolean;
+    /** 保留开头的字符数（当 preserveHead 为 true 时有效） */
+    headLength?: number;
+    /** 保留结尾的字符数（当 preserveHead 为 true 时有效） */
+    tailLength?: number;
+}
+/**
+ * 智能截断字符串，避免输出过长被截断
+ *
+ * @param str - 原始字符串
+ * @param options - 截断选项
+ * @returns 截断后的字符串
+ *
+ * @example
+ * ```typescript
+ * // 简单截断
+ * const short = truncateString(longText, { maxLength: 1000 });
+ *
+ * // 保留首尾
+ * const summary = truncateString(longText, {
+ *   preserveHead: true,
+ *   headLength: 500,
+ *   tailLength: 500
+ * });
+ * ```
+ */
+export declare function truncateString(str: string, options?: TruncateOptions): string;
+/**
+ * 截断对象/数组的字符串表示，用于日志输出
+ *
+ * @param data - 任意数据
+ * @param maxLength - 最大长度
+ * @returns 截断后的字符串
+ */
+export declare function truncateForLog(data: unknown, maxLength?: number): string;
+/**
+ * 分批处理大量数据，避免一次性输出过多
+ *
+ * @param items - 数据项数组
+ * @param batchSize - 每批大小
+ * @param processor - 处理函数
+ * @returns 处理结果
+ *
+ * @example
+ * ```typescript
+ * const results = await batchProcess(
+ *   largeArray,
+ *   100,
+ *   async (batch) => {
+ *     console.log(`Processing batch of ${batch.length} items`);
+ *     return batch.map(item => process(item));
+ *   }
+ * );
+ * ```
+ */
+export declare function batchProcess<T, R>(items: T[], batchSize: number, processor: (batch: T[], batchIndex: number) => Promise<R[]> | R[]): Promise<R[]>;
+/**
+ * 创建受限制的日志输出函数
+ *
+ * @param maxLength - 单条日志最大长度
+ * @returns 受限的日志函数
+ */
+export declare function createLimitedLogger(maxLength?: number): {
+    log: (...args: unknown[]) => void;
+    warn: (...args: unknown[]) => void;
+    error: (...args: unknown[]) => void;
+};
+/**
+ * 数据摘要生成器 - 用于生成数据的简短摘要
+ *
+ * @param data - 任意数据
+ * @returns 数据摘要
+ */
+export declare function generateSummary(data: unknown): string;

package/dist/types/utils/validation.d.ts

@@ -14,312 +14,14 @@
  * }
  * ```
  */
-/**
- * Validation error details
- */
-export interface ValidationError {
-    /** Field that failed validation */
-    field: string;
-    /** Human-readable error message */
-    message: string;
-    /** Error code for programmatic handling */
-    code: string;
-    /** Actual value that failed (optional) */
-    value?: unknown;
-}
-/**
- * Validation result
- */
-export interface ValidationResult {
-    /** Whether validation passed */
-    valid: boolean;
-    /** List of validation errors */
-    errors: ValidationError[];
-    /** Warnings (non-fatal issues) */
-    warnings?: ValidationError[];
-}
-/**
- * Validator function type
- */
-export type ValidatorFn<T = unknown> = (value: T) => ValidationResult;
-/**
- * Validation rule definition
- */
-export interface ValidationRule<T = unknown> {
-    /** Rule name */
-    name: string;
-    /** Validation function */
-    validate: (value: T) => boolean;
-    /** Error message if validation fails */
-    message: string;
-    /** Error code */
-    code: string;
-}
-/**
- * Common error codes
- */
-export declare const ValidationCodes: {
-    readonly REQUIRED: "REQUIRED";
-    readonly INVALID_TYPE: "INVALID_TYPE";
-    readonly INVALID_FORMAT: "INVALID_FORMAT";
-    readonly OUT_OF_RANGE: "OUT_OF_RANGE";
-    readonly TOO_SHORT: "TOO_SHORT";
-    readonly TOO_LONG: "TOO_LONG";
-    readonly INVALID_ENUM: "INVALID_ENUM";
-    readonly PATTERN_MISMATCH: "PATTERN_MISMATCH";
-    readonly INVALID_BUFFER: "INVALID_BUFFER";
-    readonly INVALID_ENCODING: "INVALID_ENCODING";
-    readonly EMPTY_ARRAY: "EMPTY_ARRAY";
-    readonly ARRAY_TOO_SHORT: "ARRAY_TOO_SHORT";
-    readonly ARRAY_TOO_LONG: "ARRAY_TOO_LONG";
-    readonly DUPLICATE_VALUE: "DUPLICATE_VALUE";
-    readonly NEGATIVE_VALUE: "NEGATIVE_VALUE";
-    readonly ZERO_VALUE: "ZERO_VALUE";
-    readonly NOT_A_NUMBER: "NOT_A_NUMBER";
-    readonly INFINITY_VALUE: "INFINITY_VALUE";
-    readonly INVALID_JSON: "INVALID_JSON";
-    readonly UNSUPPORTED_VALUE: "UNSUPPORTED_VALUE";
-    readonly INVALID_VERSION: "INVALID_VERSION";
-};
-/**
- * Common validation rules
- */
-export declare const CommonValidators: {
-    /** Required string (non-empty) */
-    requiredString: (field: string, value: unknown) => ValidationError | null;
-    /** Positive number */
-    positiveNumber: (field: string, value: unknown) => ValidationError | null;
-    /** Non-negative number */
-    nonNegativeNumber: (field: string, value: unknown) => ValidationError | null;
-    /** Array with items */
-    nonEmptyArray: (field: string, value: unknown) => ValidationError | null;
-    /** In range */
-    inRange: (field: string, value: unknown, min: number, max: number) => ValidationError | null;
-    /** String length */
-    stringLength: (field: string, value: unknown, min: number, max: number) => ValidationError | null;
-    /** Matches pattern */
-    matchesPattern: (field: string, value: unknown, pattern: RegExp, message?: string) => ValidationError | null;
-    /** Is one of enum values */
-    isEnum: <T extends string>(field: string, value: unknown, enumValues: readonly T[]) => ValidationError | null;
-};
-/**
- * Printer data validation schema
- */
-export interface PrinterDataSchema {
-    /** Device ID */
-    deviceId?: {
-        required?: boolean;
-        pattern?: RegExp;
-    };
-    /** Device name */
-    deviceName?: {
-        required?: boolean;
-        maxLength?: number;
-    };
-    /** Service UUID */
-    serviceUUID?: {
-        required?: boolean;
-        pattern?: RegExp;
-    };
-    /** Characteristic UUID */
-    characteristicUUID?: {
-        required?: boolean;
-        pattern?: RegExp;
-    };
-}
-/**
- * Print job data validation schema
- */
-export interface PrintJobSchema {
-    /** Job ID */
-    jobId?: {
-        required?: boolean;
-        maxLength?: number;
-    };
-    /** Data buffer */
-    data?: {
-        required?: boolean;
-        minSize?: number;
-        maxSize?: number;
-    };
-    /** Priority */
-    priority?: {
-        min?: number;
-        max?: number;
-    };
-    /** Retry count */
-    retryCount?: {
-        min?: number;
-        max?: number;
-    };
-    /** Metadata */
-    metadata?: {
-        required?: boolean;
-    };
-}
-/**
- * Validate printer connection data
- *
- * @param data - Data to validate
- * @param schema - Validation schema
- * @returns Validation result
- *
- * @example
- * ```typescript
- * const result = validatePrinterData({
- *   deviceId: 'device-123',
- *   deviceName: 'Thermal Printer',
- * }, {
- *   deviceId: { required: true },
- *   deviceName: { required: true, maxLength: 50 }
- * });
- * ```
- */
-export declare function validatePrinterData(data: Record<string, unknown>, schema: PrinterDataSchema): ValidationResult;
-/**
- * Validate print job data
- *
- * @param data - Data to validate
- * @param schema - Validation schema
- * @returns Validation result
- *
- * @example
- * ```typescript
- * const result = validatePrintJob({
- *   jobId: 'job-001',
- *   data: new ArrayBuffer(1024),
- *   priority: 5,
- * }, {
- *   jobId: { required: true },
- *   data: { required: true, minSize: 1 }
- * });
- * ```
- */
-export declare function validatePrintJob(data: Record<string, unknown>, schema: PrintJobSchema): ValidationResult;
-/**
- * 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 declare function isValidBuffer(buffer: unknown, options?: {
-    minSize?: number;
-    maxSize?: number;
-    required?: boolean;
-}): ValidationResult;
-/**
- * Validate a string is valid UUID
- *
- * @param value - Value to validate
- * @param options - Validation options
- * @returns Validation result
- *
- * @example
- * ```typescript
- * const result = isValidUUID(value, { required: true });
- * ```
- */
-export declare function isValidUUID(value: unknown, options?: {
-    required?: boolean;
-    versions?: number[];
-}): {
-    valid: boolean;
-    version?: number;
-    error?: string;
-};
-/**
- * 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 declare function validateRange(value: unknown, field: string, options?: {
-    required?: boolean;
-    min?: number;
-    max?: number;
-    integer?: boolean;
-}): ValidationResult;
-/**
- * Validate an object against a schema
- *
- * @param data - Data object to validate
- * @param rules - Validation rules per field
- * @returns Validation result
- *
- * @example
- * ```typescript
- * const result = validateObject(data, {
- *   name: [
- *     { name: 'required', validate: v => v !== undefined, message: 'Name is required', code: 'REQUIRED' },
- *     { name: 'maxLength', validate: v => v.length <= 50, message: 'Max 50 chars', code: 'TOO_LONG' }
- *   ],
- *   age: [
- *     { name: 'number', validate: v => typeof v === 'number', message: 'Must be number', code: 'INVALID_TYPE' }
- *   ]
- * });
- * ```
- */
-export declare function validateObject<T extends Record<string, unknown>>(data: T, rules: {
-    [K in keyof T]?: ValidationRule<T[K]>[];
-}): ValidationResult;
-/**
- * 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 declare function validateArray<T>(items: unknown, itemValidator: (item: T, index: number) => ValidationResult, options?: {
-    required?: boolean;
-    minItems?: number;
-    maxItems?: number;
-}): 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 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;
-}
-export declare function check(value: unknown, field: string): ChainableValidator;
+export { validatePrinterData, validatePrintJob } from './validators/printer';
+export { isValidBuffer } from './validators/buffer';
+export { isValidUUID } from './validators/uuid';
+export { validateRange } from './validators/number';
+export { validateObject } from './validators/object';
+export { validateArray } from './validators/array';
+export { check } from './validators/chain';
+export type { ChainableValidator } from './validators/chain';
+export { CommonValidators } from './validators/common';
+export { ValidationCodes } from './validators/types';
+export type { ValidationError, ValidationResult, ValidatorFn, ValidationRule, PrinterDataSchema, PrintJobSchema, } from './validators/types';

package/dist/types/utils/validators/array.d.ts

@@ -0,0 +1,19 @@
+import { 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 declare function validateArray<T>(items: unknown, itemValidator: (item: T, index: number) => ValidationResult, options?: {
+    required?: boolean;
+    minItems?: number;
+    maxItems?: number;
+}): ValidationResult;

package/dist/types/utils/validators/buffer.d.ts

@@ -0,0 +1,18 @@
+import { 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 declare function isValidBuffer(buffer: unknown, options?: {
+    minSize?: number;
+    maxSize?: number;
+    required?: boolean;
+}): ValidationResult;

package/dist/types/utils/validators/chain.d.ts

@@ -0,0 +1,31 @@
+import { 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 declare function check(value: unknown, field: string): ChainableValidator;

package/dist/types/utils/validators/common.d.ts

@@ -0,0 +1,22 @@
+import { ValidationError } from './types';
+/**
+ * Common validation rules
+ */
+export declare const CommonValidators: {
+    /** Required string (non-empty) */
+    requiredString: (field: string, value: unknown) => ValidationError | null;
+    /** Positive number */
+    positiveNumber: (field: string, value: unknown) => ValidationError | null;
+    /** Non-negative number */
+    nonNegativeNumber: (field: string, value: unknown) => ValidationError | null;
+    /** Array with items */
+    nonEmptyArray: (field: string, value: unknown) => ValidationError | null;
+    /** In range */
+    inRange: (field: string, value: unknown, min: number, max: number) => ValidationError | null;
+    /** String length */
+    stringLength: (field: string, value: unknown, min: number, max: number) => ValidationError | null;
+    /** Matches pattern */
+    matchesPattern: (field: string, value: unknown, pattern: RegExp, message?: string) => ValidationError | null;
+    /** Is one of enum values */
+    isEnum: <T extends string>(field: string, value: unknown, enumValues: readonly T[]) => ValidationError | null;
+};

package/dist/types/utils/validators/number.d.ts

@@ -0,0 +1,20 @@
+import { 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 declare function validateRange(value: unknown, field: string, options?: {
+    required?: boolean;
+    min?: number;
+    max?: number;
+    integer?: boolean;
+}): ValidationResult;

package/dist/types/utils/validators/object.d.ts

@@ -0,0 +1,24 @@
+import { ValidationResult, ValidationRule } from './types';
+/**
+ * Validate an object against a schema
+ *
+ * @param data - Data object to validate
+ * @param rules - Validation rules per field
+ * @returns Validation result
+ *
+ * @example
+ * ```typescript
+ * const result = validateObject(data, {
+ *   name: [
+ *     { name: 'required', validate: v => v !== undefined, message: 'Name is required', code: 'REQUIRED' },
+ *     { name: 'maxLength', validate: v => v.length <= 50, message: 'Max 50 chars', code: 'TOO_LONG' }
+ *   ],
+ *   age: [
+ *     { name: 'number', validate: v => typeof v === 'number', message: 'Must be number', code: 'INVALID_TYPE' }
+ *   ]
+ * });
+ * ```
+ */
+export declare function validateObject<T extends Record<string, unknown>>(data: T, rules: {
+    [K in keyof T]?: ValidationRule<T[K]>[];
+}): ValidationResult;

package/dist/types/utils/validators/printer.d.ts

@@ -0,0 +1,40 @@
+import { ValidationResult, PrinterDataSchema, PrintJobSchema } from './types';
+/**
+ * Validate printer connection data
+ *
+ * @param data - Data to validate
+ * @param schema - Validation schema
+ * @returns Validation result
+ *
+ * @example
+ * ```typescript
+ * const result = validatePrinterData({
+ *   deviceId: 'device-123',
+ *   deviceName: 'Thermal Printer',
+ * }, {
+ *   deviceId: { required: true },
+ *   deviceName: { required: true, maxLength: 50 }
+ * });
+ * ```
+ */
+export declare function validatePrinterData(data: Record<string, unknown>, schema: PrinterDataSchema): ValidationResult;
+/**
+ * Validate print job data
+ *
+ * @param data - Data to validate
+ * @param schema - Validation schema
+ * @returns Validation result
+ *
+ * @example
+ * ```typescript
+ * const result = validatePrintJob({
+ *   jobId: 'job-001',
+ *   data: new ArrayBuffer(1024),
+ *   priority: 5,
+ * }, {
+ *   jobId: { required: true },
+ *   data: { required: true, minSize: 1 }
+ * });
+ * ```
+ */
+export declare function validatePrintJob(data: Record<string, unknown>, schema: PrintJobSchema): ValidationResult;