taro-bluetooth-print 2.9.0 → 2.9.2

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

@@ -0,0 +1,125 @@
+/**
+ * Core validation types
+ */
+/**
+ * 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";
+};
+/**
+ * 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;
+    };
+}

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

@@ -0,0 +1,23 @@
+/**
+ * UUID validation
+ */
+/**
+ * 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;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "taro-bluetooth-print",
-  "version": "2.9.0",
+  "version": "2.9.2",
   "description": "Taro 蓝牙打印库 v2.6 - 轻量级、高性能、跨平台支持微信、支付宝、百度、字节跳动小程序及H5 Web Bluetooth",
   "type": "module",
   "main": "dist/index.cjs.js",

package/src/core/BluetoothPrinter.ts

@@ -118,7 +118,8 @@ export class BluetoothPrinter extends EventEmitter<PrinterEvents> {
       this.commandBuilder = commandBuilder ?? new CommandBuilder();
     } else {
       // Modern DI
-      this.connectionManager = (connectionManagerOrAdapter as IConnectionManager) ?? new ConnectionManager();
+      this.connectionManager =
+        (connectionManagerOrAdapter as IConnectionManager) ?? new ConnectionManager();
       this.printJobManager = printJobManager ?? new PrintJobManager(this.connectionManager);
       this.commandBuilder = commandBuilder ?? new CommandBuilder();
     }

package/src/core/di/Container.ts

@@ -0,0 +1,332 @@
+/**
+ * 依赖注入容器
+ * 提供现代化的依赖管理和服务定位功能
+ */
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type Constructor<T = object> = new (...args: any[]) => T;
+export type Factory<T> = (container: Container) => T;
+export type Provider<T> = Constructor<T> | Factory<T> | T;
+
+export interface RegistrationOptions {
+  /** 是否单例 */
+  singleton?: boolean;
+  /** 生命周期 */
+  lifecycle?: 'transient' | 'singleton' | 'scoped';
+  /** 标签，用于区分同一接口的不同实现 */
+  tag?: string;
+}
+
+/**
+ * Angular 风格的服务提供者配置
+ */
+export interface ServiceProviderConfig<T = unknown> {
+  /** 使用类 */
+  useClass?: Constructor<T>;
+  /** 使用工厂函数 */
+  useFactory?: Factory<T>;
+  /** 使用实例值 */
+  useValue?: T;
+  /** 生命周期 */
+  lifecycle?: 'transient' | 'singleton' | 'scoped';
+  /** 依赖项 */
+  dependencies?: (string | symbol | Constructor<unknown>)[];
+}
+
+interface Registration<T> {
+  provider: Provider<T>;
+  options: RegistrationOptions;
+  instance?: T;
+}
+
+export class Container {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  private registrations = new Map<string | symbol, Registration<any>[]>();
+  private parent?: Container;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  private scopedInstances = new Map<string | symbol, any>();
+
+  constructor(parent?: Container) {
+    this.parent = parent;
+  }
+
+  /**
+   * 创建子容器
+   */
+  createChild(): Container {
+    return new Container(this);
+  }
+
+  /**
+   * 注册服务
+   */
+  register<T>(
+    token: string | symbol | Constructor<T>,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    provider: Provider<T> | ServiceProviderConfig<T>,
+    options: RegistrationOptions = {}
+  ): this {
+    const key = this.getTokenKey(token);
+
+    // 支持 ServiceProviderConfig 格式
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const config = provider as ServiceProviderConfig<T>;
+
+    // 如果是对象语法（Angular 风格）
+    if (
+      config &&
+      typeof config === 'object' &&
+      (config.useClass || config.useFactory || config.useValue !== undefined)
+    ) {
+      let actualProvider: Provider<T>;
+
+      if (config.useClass) {
+        // 使用类 - 创建工厂函数来解析依赖
+        const Cls = config.useClass;
+        actualProvider = (container: Container) => {
+          return container.createInstance(Cls);
+        };
+      } else if (config.useFactory) {
+        actualProvider = config.useFactory;
+      } else {
+        actualProvider = config.useValue as T;
+      }
+
+      const registration: Registration<T> = {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        provider: actualProvider,
+        options: {
+          lifecycle: config.lifecycle || 'transient',
+          ...options,
+        },
+      };
+
+      if (!this.registrations.has(key)) {
+        this.registrations.set(key, []);
+      }
+      this.registrations.get(key)!.push(registration);
+      return this;
+    }
+
+    // 原有逻辑：Provider<T> 格式
+    const registration: Registration<T> = {
+      provider: provider as Provider<T>,
+      options: {
+        lifecycle: 'transient',
+        ...options,
+      },
+    };
+
+    if (!this.registrations.has(key)) {
+      this.registrations.set(key, []);
+    }
+    this.registrations.get(key)!.push(registration);
+    return this;
+  }
+
+  /**
+   * 注册单例服务
+   */
+  registerSingleton<T>(token: string | symbol | Constructor<T>, provider: Provider<T>): this {
+    return this.register(token, provider, { lifecycle: 'singleton' });
+  }
+
+  /**
+   * 注册类型映射
+   */
+  registerType<T>(
+    from: string | symbol | Constructor<T>,
+    to: Constructor<T>,
+    options: RegistrationOptions = {}
+  ): this {
+    return this.register(from, c => c.resolve(to), options);
+  }
+
+  /**
+   * 注册实例
+   */
+  registerInstance<T>(token: string | symbol | Constructor<T>, instance: T): this {
+    return this.register(token, instance, { lifecycle: 'singleton' });
+  }
+
+  /**
+   * 解析服务
+   */
+  resolve<T>(token: string | symbol | Constructor<T>, tag?: string): T {
+    const key = this.getTokenKey(token);
+
+    // 1. 检查当前容器的注册
+    const registrations = this.registrations.get(key);
+    if (registrations) {
+      const registration = tag
+        ? registrations.find(r => r.options.tag === tag)
+        : registrations[registrations.length - 1];
+
+      if (registration) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+        return this.getOrCreateInstance(registration, key);
+      }
+    }
+
+    // 2. 检查父容器
+    if (this.parent) {
+      return this.parent.resolve(token, tag);
+    }
+
+    // 3. 如果是构造函数，自动创建实例
+    if (typeof token === 'function' && this.isConstructor(token)) {
+      return this.createInstance(token);
+    }
+
+    throw new Error(`No registration found for token: ${String(key)}`);
+  }
+
+  /**
+   * 解析所有注册的服务
+   */
+  resolveAll<T>(token: string | symbol | Constructor<T>): T[] {
+    const key = this.getTokenKey(token);
+    const results: T[] = [];
+
+    // 从当前容器获取
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const registrations = this.registrations.get(key);
+    if (registrations) {
+      for (const r of registrations) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+        results.push(this.getOrCreateInstance(r, key));
+      }
+    }
+
+    // 从父容器获取
+    if (this.parent) {
+      results.push(...this.parent.resolveAll(token));
+    }
+
+    return results;
+  }
+
+  /**
+   * 检查是否已注册
+   */
+  isRegistered<T>(token: string | symbol | Constructor<T>): boolean {
+    const key = this.getTokenKey(token);
+    return this.registrations.has(key) || (this.parent?.isRegistered(token) ?? false);
+  }
+
+  /**
+   * 清除所有注册
+   */
+  clear(): void {
+    this.registrations.clear();
+    this.scopedInstances.clear();
+  }
+
+  /**
+   * 创建作用域
+   */
+  createScope(): Container {
+    const scope = this.createChild();
+    return scope;
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  private getTokenKey(token: string | symbol | Constructor<any>): string | symbol {
+    if (typeof token === 'function') {
+      return token.name || (token as unknown as symbol);
+    }
+    return token;
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+  private isConstructor(fn: Function): boolean {
+    return (
+      typeof fn.prototype === 'object' &&
+      fn.prototype !== null &&
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+      fn.prototype.constructor === fn
+    );
+  }
+
+  private getOrCreateInstance<T>(registration: Registration<T>, key: string | symbol): T {
+    const { provider, options } = registration;
+
+    // 单例模式
+    if (options.lifecycle === 'singleton') {
+      if (registration.instance === undefined) {
+        registration.instance = this.createProviderInstance(provider);
+      }
+      return registration.instance;
+    }
+
+    // 作用域模式
+    if (options.lifecycle === 'scoped') {
+      if (this.scopedInstances.has(key)) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+        return this.scopedInstances.get(key) as T;
+      }
+      const instance = this.createProviderInstance(provider);
+      this.scopedInstances.set(key, instance);
+      return instance;
+    }
+
+    // 瞬态模式
+    return this.createProviderInstance(provider);
+  }
+
+  private createProviderInstance<T>(provider: Provider<T>): T {
+    if (typeof provider === 'function') {
+      // 工厂函数
+      if (provider.length === 1 && !this.isConstructor(provider)) {
+        return (provider as Factory<T>)(this);
+      }
+      // 构造函数
+      return this.createInstance(provider as Constructor<T>);
+    }
+    // 实例
+    return provider;
+  }
+
+  private createInstance<T>(constructor: Constructor<T>): T {
+    // 获取构造函数的参数类型（简化实现，实际可能需要反射元数据）
+    const paramCount = constructor.length;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const args: any[] = [];
+
+    for (let i = 0; i < paramCount; i++) {
+      // 尝试从容器解析参数
+      // 这里简化处理，实际应该使用参数装饰器
+      args.push(undefined);
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+    return new constructor(...args);
+  }
+}
+
+// 全局容器实例
+export const rootContainer = new Container();
+
+// 装饰器辅助函数
+export function injectable<T extends Constructor<object>>(constructor: T): T {
+  // 标记类为可注入
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+  (constructor as Constructor & { __injectable: boolean }).__injectable = true;
+  return constructor;
+}
+
+export function inject(token: string | symbol) {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  return function (target: any, _propertyKey: string | symbol, parameterIndex: number) {
+    // 存储注入元数据
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+    const existingInjections: (string | symbol)[] =
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+      (target.__injections as (string | symbol)[]) || [];
+    existingInjections[parameterIndex] = token;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+    target.__injections = existingInjections;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+    return target;
+  };
+}

package/src/core/di/Tokens.ts

@@ -0,0 +1,45 @@
+/**
+ * 服务标识符（Tokens）
+ * 用于依赖注入的常量定义
+ */
+
+// 适配器相关
+export const ADAPTER_TOKEN = Symbol.for('Adapter');
+export const ADAPTER_FACTORY_TOKEN = Symbol.for('AdapterFactory');
+
+// 驱动相关
+export const DRIVER_TOKEN = Symbol.for('Driver');
+export const DRIVER_FACTORY_TOKEN = Symbol.for('DriverFactory');
+
+// 服务相关
+export const DEVICE_MANAGER_TOKEN = Symbol.for('DeviceManager');
+export const CONNECTION_MANAGER_TOKEN = Symbol.for('ConnectionManager');
+export const PRINT_JOB_MANAGER_TOKEN = Symbol.for('PrintJobManager');
+export const PRINT_QUEUE_TOKEN = Symbol.for('PrintQueue');
+export const OFFLINE_CACHE_TOKEN = Symbol.for('OfflineCache');
+export const CONFIG_MANAGER_TOKEN = Symbol.for('ConfigManager');
+
+// 新增服务令牌
+export const COMMAND_BUILDER_TOKEN = Symbol.for('CommandBuilder');
+export const PRINTER_STATUS_TOKEN = Symbol.for('PrinterStatus');
+export const PRINT_HISTORY_TOKEN = Symbol.for('PrintHistory');
+export const PRINT_STATISTICS_TOKEN = Symbol.for('PrintStatistics');
+export const CLOUD_PRINT_MANAGER_TOKEN = Symbol.for('CloudPrintManager');
+export const SCHEDULED_RETRY_MANAGER_TOKEN = Symbol.for('ScheduledRetryManager');
+export const BATCH_PRINT_MANAGER_TOKEN = Symbol.for('BatchPrintManager');
+
+// 工具服务
+export const LOGGER_TOKEN = Symbol.for('Logger');
+export const ENCODING_SERVICE_TOKEN = Symbol.for('EncodingService');
+export const IMAGE_PROCESSING_TOKEN = Symbol.for('ImageProcessing');
+export const BARCODE_GENERATOR_TOKEN = Symbol.for('BarcodeGenerator');
+export const TEMPLATE_ENGINE_TOKEN = Symbol.for('TemplateEngine');
+
+// 事件系统
+export const EVENT_BUS_TOKEN = Symbol.for('EventBus');
+
+// 插件系统
+export const PLUGIN_MANAGER_TOKEN = Symbol.for('PluginManager');
+
+// 性能监控
+export const PERFORMANCE_MONITOR_TOKEN = Symbol.for('PerformanceMonitor');

package/src/core/di/index.ts

@@ -0,0 +1,3 @@
+export { Container, rootContainer, injectable, inject } from './Container';
+export type { ServiceProviderConfig, RegistrationOptions } from './Container';
+export * from './Tokens';