@laiye_packages/uci 1.0.0

package/dist/http/base.d.ts

@@ -0,0 +1,52 @@
+import { type AxiosInstance } from 'axios';
+import { LYObject } from '../object';
+import { type LYHttpRetryConfig } from '../config/http';
+export type LYHttpRequestConfig = {
+    method?: LYHttpRequestMethod;
+    url?: string;
+    baseURL?: string;
+    headers?: Record<string, string>;
+    params?: Record<string, any>;
+    data?: Record<string, any>;
+    timeout?: number;
+    withCredentials?: boolean;
+    onUploadProgress?: (progress: number) => void;
+    onDownloadProgress?: (progress: number) => void;
+    signal?: AbortSignal;
+    responseType?: 'arraybuffer' | 'blob' | 'document' | 'json' | 'text' | 'stream' | 'formdata';
+};
+export interface ILYHttpClient {
+    get<T>(url: string, query?: Record<string, any>): Promise<T>;
+    post<T>(url: string, data?: Record<string, any>): Promise<T>;
+    put<T>(url: string, data?: Record<string, any>): Promise<T>;
+    delete<T>(url: string, query?: Record<string, any>): Promise<T>;
+    patch<T>(url: string, data?: Record<string, any>): Promise<T>;
+}
+export type LYHttpRequestMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+export interface LYKeyConverter {
+    convert_request(key: string): string;
+    convert_response(key: string): string;
+}
+export declare class LYSnakeCaseDataConverter implements LYKeyConverter {
+    convert_request(key: string): string;
+    convert_response(key: string): string;
+}
+export declare class LYHttpClient extends LYObject implements ILYHttpClient {
+    private _baseUrl;
+    private _key_converter?;
+    protected _client: AxiosInstance;
+    constructor(baseUrl?: string);
+    get baseUrl(): string;
+    get key_converter(): LYKeyConverter | undefined;
+    set key_converter(converter: LYKeyConverter | undefined);
+    private _convert_request;
+    private _convert_response;
+    protected _get_headers(): Record<string, string> | undefined;
+    protected _request(config: LYHttpRequestConfig): Promise<any>;
+    withRetry(fn: (config: LYHttpRetryConfig) => LYHttpRetryConfig): Promise<this>;
+    get<TResponse = Record<string, any>, TQuery = Record<string, any>>(url: string, query?: TQuery, config?: LYHttpRequestConfig): Promise<TResponse>;
+    post<TResponse = Record<string, any>, TData = Record<string, any>>(url: string, data?: TData, config?: LYHttpRequestConfig): Promise<TResponse>;
+    put<TResponse = Record<string, any>, TData = Record<string, any>>(url: string, data?: TData, config?: LYHttpRequestConfig): Promise<TResponse>;
+    delete<TResponse = Record<string, any>, TQuery = Record<string, any>>(url: string, query?: TQuery, config?: LYHttpRequestConfig): Promise<TResponse>;
+    patch<TResponse = Record<string, any>, TData = Record<string, any>>(url: string, data?: TData, config?: LYHttpRequestConfig): Promise<TResponse>;
+}

package/dist/http/error.d.ts

@@ -0,0 +1,34 @@
+import { LYError } from '../error';
+export type LYBasicResultCode = 'success' | 'failed' | 'invalid_params' | 'exists' | 'not_exists' | 'forbidden' | 'timeout' | 'expired';
+export declare class LYBaseHttpError extends LYError {
+    private _url;
+    private _method;
+    private _inner_error;
+    constructor(message: string, url: string, method: string, inner_error: Error);
+    get url(): string;
+    get method(): string;
+    get inner_error(): Error;
+}
+export declare class LYConfigError extends LYBaseHttpError {
+}
+export declare class LYNetworkError extends LYBaseHttpError {
+}
+export declare enum LYHttpStatus {
+    SUCCESS = 200,
+    BAD_REQUEST = 400,
+    UNAUTHORIZED = 401,
+    FORBIDDEN = 403,
+    NOT_FOUND = 404,
+    TOO_MANY_REQUESTS = 429,
+    INTERNAL_SERVER_ERROR = 500
+}
+export declare class LYHttpStatusError extends LYBaseHttpError {
+    private _status;
+    constructor(message: string, url: string, method: string, inner_error: Error, status: number);
+    get status(): number;
+    getStatus(): LYHttpStatus | undefined;
+}
+export declare class LYAppHttpError extends LYBaseHttpError {
+    constructor(message: string, url: string, method: string, inner_error: Error, code: string);
+    getCode<T extends LYBasicResultCode = LYBasicResultCode>(): T;
+}

package/dist/http/index.d.ts

@@ -0,0 +1,170 @@
+import { LYEvents } from '../object';
+import { type LYBasicResultCode } from './error';
+import { LYHttpClient, LYHttpRequestConfig } from './base';
+import { AxiosResponse } from 'axios';
+export interface LYSSEConfig {
+    data?: Record<string, any>;
+    delimiter?: string;
+    signal?: AbortSignal;
+    headers?: Record<string, string>;
+}
+export type LYSortQueryParams = {
+    sort: string[];
+};
+export type LYRangeQueryParams = {
+    offset: number;
+    size: number;
+    sort: string[];
+};
+export interface LYBaseResponse {
+}
+export interface LYBaseDataResponse extends LYBaseResponse {
+    id: string;
+    created_at: string;
+    updated_at: string;
+    updated_by?: string;
+}
+interface LYRangeResponse extends LYBaseResponse {
+    offset: number;
+    size: number;
+    total?: number;
+}
+interface LYBaseResultResponse extends LYBaseResponse {
+    message: string;
+    tips?: string;
+}
+export interface LYIdentifierResponse extends LYBaseResponse {
+    id: string;
+}
+export interface LYCountResponse extends LYBaseResponse {
+    count: number;
+}
+export interface LYResultResponse<T extends LYBaseResponse, C = LYBasicResultCode> extends LYBaseResultResponse {
+    code: C;
+    data?: T;
+}
+export interface LYListResponse<T extends LYBaseResponse> extends LYBaseResponse {
+    range?: LYRangeResponse;
+    list: T[];
+}
+export interface IHeaderProvider {
+    headers?: Record<string, string>;
+}
+export interface LYUploadResponse {
+    id: string;
+    state: LYUploadState;
+}
+export interface LYUploadParams {
+    id?: string;
+    ref_id?: string;
+    ref_type?: string;
+    expire?: number | string;
+    ignore_session?: boolean;
+    extra?: Record<string, any>;
+    encryption?: boolean;
+    state?: LYUploadState;
+    level?: 'default' | 'low';
+    chunk?: File;
+    total_size?: number;
+}
+type LYUploadState = {
+    bucket: string;
+    key: string;
+    completed_size: number;
+    upload_id: string;
+    part_number: number;
+    parts: {
+        PartNumber: number;
+        ETag: string;
+    }[];
+};
+export interface LYDeleteResponse {
+    count: number;
+}
+type LYUploadFailedEvent = {
+    file: File;
+    error: Error;
+    fileId: string;
+    state: LYUploadState;
+    params: LYUploadParams;
+    failedChunkIndex: number;
+    uploadedChunks: number;
+};
+type LYDownloadFailedEvent = {
+    error: Error;
+    fileId: string;
+    fileName?: string;
+    blob?: Blob;
+};
+type LYUploadEvents = {
+    upload_failed(event: LYUploadFailedEvent): void;
+    download_failed(event: LYDownloadFailedEvent): void;
+};
+export interface LYDownloadResult {
+    blob: Blob;
+    fileName: string;
+    contentType: string;
+    totalSize: number;
+}
+export declare class LYAppHttpClient extends LYHttpClient {
+    on: LYEvents<LYUploadEvents>['on'];
+    off: LYEvents<LYUploadEvents>['on'];
+    once: LYEvents<LYUploadEvents>['on'];
+    addListener: LYEvents<LYUploadEvents>['on'];
+    removeListener: LYEvents<LYUploadEvents>['on'];
+    emit: LYEvents<LYUploadEvents>['emit'];
+    private _headerProvider;
+    constructor(app_name: string, headerProvider: IHeaderProvider);
+    protected _getUrl(url: string): string;
+    protected _get_headers(): Record<string, string> | undefined;
+    _request<T extends LYBaseResponse>(config?: LYHttpRequestConfig): Promise<LYResultResponse<T> | AxiosResponse<any> | undefined>;
+    /**
+     * 上传文件
+     */
+    uploadFile(params: LYUploadParams, config?: LYHttpRequestConfig): Promise<LYResultResponse<LYUploadResponse>>;
+    /**
+     * 分块上传文件
+     */
+    uploadFileInChunks(params: LYUploadParams, config?: LYHttpRequestConfig & {
+        chunkSize?: number;
+        onProgress?: (progress: number) => void;
+        startChunkIndex?: number;
+    }): Promise<LYUploadResponse>;
+    download(fileId: string, fileName?: string, config?: LYHttpRequestConfig & {
+        chunkSize?: number;
+        onProgress?: (progress: number) => void;
+        resumeFromByte?: number;
+    }): Promise<LYDownloadResult>;
+    downloadFile(fileId: string, fileName?: string, config?: LYHttpRequestConfig): Promise<void>;
+    /**
+     * SSE流式请求 - 字符串格式
+     * @param url 请求URL
+     * @param config SSE配置选项
+     * @returns AsyncGenerator<string>，生成原始字符串数据
+     */
+    stream(url: string, config?: LYSSEConfig): AsyncGenerator<string>;
+    /**
+     * SSE流式请求 - Uint8Array格式
+     * @param url 请求URL
+     * @param config SSE配置选项
+     * @returns AsyncGenerator<Uint8Array>，生成字节数组数据
+     */
+    stream(url: string, config?: LYSSEConfig): AsyncGenerator<Uint8Array>;
+    /**
+     * SSE流式请求 - JSON格式
+     * @param url 请求URL
+     * @param config SSE配置选项
+     * @returns AsyncGenerator<T>，生成JSON解析后的数据
+     */
+    stream<T>(url: string, config?: LYSSEConfig): AsyncGenerator<T>;
+    /**
+     * 智能解析数据块
+     * 根据调用上下文的泛型类型自动选择解析方式
+     */
+    private parseChunk;
+}
+export declare class LYTenantHttpClient extends LYAppHttpClient {
+    static getTenantName(): string;
+    protected _getUrl(url: string): string;
+}
+export {};

package/dist/http/trace.d.ts

@@ -0,0 +1 @@
+export declare function initialize(attrs: Record<string, string>): void;

package/dist/i18n/index.d.ts

@@ -0,0 +1,50 @@
+import type { TOptions } from 'i18next';
+import type { ILYEvents, LYEvents } from '../object';
+import { LYObject } from '../object';
+type LYTranslateOptions = TOptions;
+export type LYTranslateMethod = (key: string, options?: LYTranslateOptions) => string;
+type LYi18nEvents = {
+    ['lang-changed'](lang: string): void;
+};
+export declare enum LYLangEnum {
+    'zh-CN' = "\u7B80\u4F53\u4E2D\u6587",
+    'en-US' = "English"
+}
+export type LYKeyofLang = keyof typeof LYLangEnum;
+export declare const langKeys: LYKeyofLang[];
+export declare const languages: Partial<Record<LYKeyofLang, string>>;
+export interface ILYi18n extends ILYEvents<LYi18nEvents> {
+    readonly lang: LYKeyofLang;
+    readonly languages: Partial<Record<LYKeyofLang, string>>;
+    getUrlResource(url: string): Promise<Object | undefined>;
+    loadResource(urlOrJson: string | object, lang?: LYKeyofLang): Promise<void>;
+    changeLanguage(lang: LYKeyofLang): Promise<void>;
+    t: LYTranslateMethod;
+}
+export declare const LANG_KEY = "lang";
+export declare class LYi18n extends LYObject implements ILYi18n {
+    on: LYEvents<LYi18nEvents>['on'];
+    off: LYEvents<LYi18nEvents>['on'];
+    once: LYEvents<LYi18nEvents>['on'];
+    emit: LYEvents<LYi18nEvents>['emit'];
+    private _namespace;
+    private _lang;
+    constructor(namespace?: string);
+    get t(): LYTranslateMethod;
+    get lang(): LYKeyofLang;
+    get languages(): Partial<Record<LYKeyofLang, string>>;
+    get namespace(): string;
+    initialize(): Promise<void>;
+    private fallbackLng;
+    /**
+     * 解析当前环境语言
+     * @returns 解析得到的语言
+     * @private
+     */
+    private resolveLanguage;
+    loadResource(urlOrJson: string | object, lang?: LYKeyofLang, namespace?: string): Promise<void>;
+    getUrlResource(resourceUrl: string): Promise<object | undefined>;
+    changeLanguage(lang: LYKeyofLang): Promise<void>;
+    getResource(key: string, lang?: string): Record<string, string>;
+}
+export {};

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+export * from './logger';
+export * from './object';
+export * from './error';
+export * from './env';
+export * from './config';
+export * from './constants';
+export * from './observable';
+export * from './storage';
+export * from './http';
+export * from './i18n';
+export * from './app';
+export * from './permission';
+export * from './session';
+export * from './crypto';