@douyinfe/semi-foundation 2.28.0-beta.0 → 2.28.0

package/lib/cjs/typography/constants.d.ts

@@ -0,0 +1,12 @@
+declare const cssClasses: {
+    PREFIX: string;
+};
+declare const strings: {
+    readonly TYPE: readonly ["primary", "secondary", "danger", "warning", "success", "tertiary", "quaternary"];
+    readonly SIZE: readonly ["normal", "small"];
+    readonly SPACING: readonly ["normal", "extended"];
+    readonly HEADING: readonly [1, 2, 3, 4, 5, 6];
+    readonly RULE: readonly ["text", "numbers", "bytes-decimal", "bytes-binary", "percentages", "exponential"];
+    readonly TRUNCATE: readonly ["ceil", "floor", "round"];
+};
+export { cssClasses, strings };

package/lib/cjs/typography/constants.js

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.strings = exports.cssClasses = void 0;
+
+var _constants = require("../base/constants");
+
+const cssClasses = {
+  PREFIX: `${_constants.BASE_CLASS_PREFIX}-typography`
+};
+exports.cssClasses = cssClasses;
+const strings = {
+  TYPE: ['primary', 'secondary', 'danger', 'warning', 'success', 'tertiary', 'quaternary'],
+  SIZE: ['normal', 'small'],
+  SPACING: ['normal', 'extended'],
+  HEADING: [1, 2, 3, 4, 5, 6],
+  RULE: ['text', 'numbers', 'bytes-decimal', 'bytes-binary', 'percentages', 'exponential'],
+  TRUNCATE: ['ceil', 'floor', 'round']
+};
+exports.strings = strings;

package/lib/cjs/typography/formatNumeral.d.ts

@@ -0,0 +1,18 @@
+import { strings } from './constants';
+declare type Rule = typeof strings.RULE[number];
+declare type Truncate = typeof strings.TRUNCATE[number];
+declare type Parser = (value: string) => string;
+export default class FormatNumeral {
+    private readonly content;
+    private readonly rule;
+    private readonly precision;
+    private readonly truncate;
+    private readonly parser;
+    private readonly isDiyParser;
+    private readonly ruleMethods;
+    private readonly truncateMethods;
+    constructor(content: string, rule: Rule, precision: number, truncate: Truncate, parser: Parser | undefined);
+    format(): string;
+    private truncatePrecision;
+}
+export {};

package/lib/cjs/typography/formatNumeral.js

@@ -0,0 +1,114 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+class FormatNumeral {
+  constructor(content, rule, precision, truncate, parser) {
+    // A collection of methods for formatting numbers;  Methods key: Rule (strings.RULE);  Not included: 'text' & 'numbers'
+    this.ruleMethods = {
+      'bytes-decimal': value => {
+        const units = ['B', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];
+        let i = 0;
+
+        while (value >= 1000) {
+          value /= 1000;
+          i++;
+        }
+
+        return `${this.truncatePrecision(value)} ${units[i]}`;
+      },
+      'bytes-binary': value => {
+        const units = ['B', 'KiB', 'MiB', 'GiB', 'TiB', 'PiB', 'EiB', 'ZiB', 'YiB'];
+        let i = 0;
+
+        while (value >= 1024) {
+          value /= 1024;
+          i++;
+        }
+
+        return `${this.truncatePrecision(value)} ${units[i]}`;
+      },
+      percentages: value => {
+        const cArr = value.toString().split('.');
+
+        if (Number(cArr[0]) === 0) {
+          return `${this.truncatePrecision(value * 100)}%`;
+        }
+
+        return `${this.truncatePrecision(value)}%`;
+      },
+      exponential: value => {
+        const vExponential = value.toExponential(this.precision + 2);
+        const vArr = vExponential.split('e');
+        return `${this.truncatePrecision(Number(vArr[0]))}e${vArr[1]}`;
+      }
+    }; // A collection of methods for truncating numbers; Methods key: Truncate (strings.Truncate);
+
+    this.truncateMethods = {
+      ceil: Math.ceil,
+      floor: Math.floor,
+      round: Math.round
+    };
+    this.isDiyParser = typeof parser !== 'undefined';
+    this.content = content;
+    this.rule = rule;
+    this.precision = precision;
+    this.truncate = truncate;
+    this.parser = parser;
+  } // Formatting numbers within a string.
+
+
+  format() {
+    // Executed when a custom method exists
+    if (this.isDiyParser) {
+      return this.parser(this.content);
+    } //  When the `rule` is `text`, only the `truncatePrecision` method is executed for numeric processing.
+
+
+    if (this.rule === 'text') {
+      return extractNumbers(this.content).map(item => checkIsNumeral(item) ? this.truncatePrecision(item) : item).join('');
+    } // Separate extraction of numbers when `rule` is `numbers`.
+
+
+    if (this.rule === 'numbers') {
+      return extractNumbers(this.content).filter(item => checkIsNumeral(item)).map(item => this.truncatePrecision(item)).join(',');
+    } // Run formatting methods that exist.
+
+
+    return extractNumbers(this.content).map(item => checkIsNumeral(item) ? this.ruleMethods[this.rule](Number(item)) : item).join('');
+  }
+
+  truncatePrecision(content) {
+    // Truncation and selection of rounding methods for processing. function from: truncateMethods
+    const cTruncated = this.truncateMethods[this.truncate](Number(content) * Math.pow(10, this.precision)) / Math.pow(10, this.precision);
+    const cArr = cTruncated.toString().split('.'); // is an integer then the end number is normalised
+
+    if (cArr.length === 1) {
+      return cTruncated.toFixed(this.precision);
+    }
+
+    const cTLength = cArr[1].length; // Fill in any missing `0` at the end.
+
+    if (cTLength < this.precision) {
+      return `${cArr[0]}.${cArr[1]}${'0'.repeat(this.precision - cTLength)}`;
+    }
+
+    return cTruncated.toString();
+  }
+
+} // Separate numbers from strings, the `-` symbol is a numeric prefix not allowed on its own.
+
+
+exports.default = FormatNumeral;
+
+function extractNumbers(content) {
+  const reg = /(-?[0-9]*\.?[0-9]+([eE]-?[0-9]+)?)|([^-\d\.]+)/g;
+  return content.match(reg) || [];
+}
+
+function checkIsNumeral(str) {
+  return !(isNaN(Number(str)) || str.replace(/\s+/g, '') === '');
+}

package/lib/cjs/upload/constants.d.ts

@@ -0,0 +1,28 @@
+declare const cssClasses: {
+    PREFIX: string;
+    LIST: string;
+};
+declare const strings: {
+    FILE_STATUS_UPLOADING: string;
+    FILE_STATUS_SUCCESS: string;
+    FILE_STATUS_UPLOAD_FAIL: string;
+    FILE_STATUS_VALIDATING: string;
+    FILE_STATUS_VALID_FAIL: string;
+    FILE_STATUS_WAIT_UPLOAD: string;
+    FILE_LIST_PIC: "picture";
+    FILE_LIST_DEFAULT: "list";
+    LIST_TYPE: ("picture" | "list")[];
+    imageTypes: string[];
+    DRAG_AREA_DEFAULT: string;
+    DRAG_AREA_LEGAL: string;
+    DRAG_AREA_ILLEGAL: string;
+    TRIGGER_AUTO: "auto";
+    TRIGGER_CUSTOM: "custom";
+    UPLOAD_TRIGGER: ("auto" | "custom")[];
+    VALIDATE_STATUS: readonly ["default", "error", "warning", "success"];
+    PROMPT_POSITION: readonly ["left", "right", "bottom"];
+};
+declare const numbers: {
+    PROGRESS_COEFFICIENT: number;
+};
+export { cssClasses, strings, numbers };

package/lib/cjs/upload/constants.js

@@ -0,0 +1,46 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.strings = exports.numbers = exports.cssClasses = void 0;
+
+var _constants = require("../base/constants");
+
+const PREFIX = `${_constants.BASE_CLASS_PREFIX}-upload`;
+const FILE_LIST_PIC = 'picture';
+const FILE_LIST_DEFAULT = 'list';
+const PROGRESS_COEFFICIENT = 0.95;
+const cssClasses = {
+  PREFIX,
+  // WRAPPER: `${PREFIX}-wrapper`,
+  LIST: `${PREFIX}-list`
+};
+exports.cssClasses = cssClasses;
+const TRIGGER_AUTO = 'auto';
+const TRIGGER_CUSTOM = 'custom';
+const strings = {
+  FILE_STATUS_UPLOADING: 'uploading',
+  FILE_STATUS_SUCCESS: 'success',
+  FILE_STATUS_UPLOAD_FAIL: 'uploadFail',
+  FILE_STATUS_VALIDATING: 'validating',
+  FILE_STATUS_VALID_FAIL: 'validateFail',
+  FILE_STATUS_WAIT_UPLOAD: 'wait',
+  FILE_LIST_PIC,
+  FILE_LIST_DEFAULT,
+  LIST_TYPE: [FILE_LIST_PIC, FILE_LIST_DEFAULT],
+  imageTypes: ['image', 'webp', 'png', 'svg', 'gif', 'jpg', 'jpeg', 'bmp', 'dpg'],
+  DRAG_AREA_DEFAULT: 'default',
+  DRAG_AREA_LEGAL: 'legal',
+  DRAG_AREA_ILLEGAL: 'illegal',
+  TRIGGER_AUTO,
+  TRIGGER_CUSTOM,
+  UPLOAD_TRIGGER: [TRIGGER_AUTO, TRIGGER_CUSTOM],
+  VALIDATE_STATUS: _constants.VALIDATE_STATUS,
+  PROMPT_POSITION: ['left', 'right', 'bottom']
+};
+exports.strings = strings;
+const numbers = {
+  PROGRESS_COEFFICIENT
+};
+exports.numbers = numbers;

package/lib/cjs/upload/foundation.d.ts

@@ -0,0 +1,167 @@
+import BaseFoundation, { DefaultAdapter } from '../base/foundation';
+export interface XhrError extends Error {
+    status: XMLHttpRequest['status'];
+    method: string;
+    url: string;
+}
+export declare type FileItemStatus = 'success' | 'uploadFail' | 'validateFail' | 'validating' | 'uploading' | 'wait';
+export interface BaseFileItem {
+    showReplace?: boolean;
+    showRetry?: boolean;
+    response?: any;
+    event?: Event;
+    status: FileItemStatus;
+    name: string;
+    size: string;
+    uid: string;
+    url?: string;
+    fileInstance?: File;
+    percent?: number;
+    _sizeInvalid?: boolean;
+    preview?: boolean;
+    validateMessage?: any;
+    shouldUpload?: boolean;
+    [key: string]: any;
+}
+export interface CustomFile extends File {
+    uid?: string;
+    _sizeInvalid?: boolean;
+    status?: string;
+}
+export interface BeforeUploadObjectResult {
+    shouldUpload?: boolean;
+    status?: string;
+    autoRemove?: boolean;
+    validateMessage?: unknown;
+    fileInstance?: CustomFile;
+}
+export interface AfterUploadResult {
+    autoRemove?: boolean;
+    status?: string;
+    validateMessage?: unknown;
+    name?: string;
+}
+export interface UploadAdapter<P = Record<string, any>, S = Record<string, any>> extends DefaultAdapter<P, S> {
+    notifyFileSelect: (files: Array<CustomFile>) => void;
+    notifyError: (error: XhrError, fileInstance: File, fileList: Array<BaseFileItem>, xhr: XMLHttpRequest) => void;
+    notifySuccess: (body: any, fileInstance: File, newFileList: Array<BaseFileItem>) => void;
+    notifyProgress: (percent: number, fileInstance: File, newFileList: Array<BaseFileItem>) => void;
+    notifyRemove: (file: File, newFileList: Array<BaseFileItem>, fileItem: BaseFileItem) => void;
+    notifySizeError: (file: File, fileList: Array<BaseFileItem>) => void;
+    notifyExceed: (files: Array<File>) => void;
+    updateFileList: (newFileList: Array<BaseFileItem>, callback?: () => void) => void;
+    notifyBeforeUpload: ({ file, fileList }: {
+        file: BaseFileItem;
+        fileList: Array<BaseFileItem>;
+    }) => boolean | BeforeUploadObjectResult | Promise<BeforeUploadObjectResult>;
+    notifyAfterUpload: ({ response, file, fileList }: {
+        response: any;
+        file: BaseFileItem;
+        fileList: Array<BaseFileItem>;
+    }) => AfterUploadResult;
+    resetInput: () => void;
+    resetReplaceInput: () => void;
+    updateDragAreaStatus: (dragAreaStatus: string) => void;
+    notifyBeforeRemove: (file: BaseFileItem, fileList: Array<BaseFileItem>) => boolean | Promise<boolean>;
+    notifyBeforeClear: (fileList: Array<BaseFileItem>) => boolean | Promise<boolean>;
+    notifyChange: ({ currentFile, fileList }: {
+        currentFile: BaseFileItem | null;
+        fileList: Array<BaseFileItem>;
+    }) => void;
+    updateLocalUrls: (urls: Array<string>) => void;
+    notifyClear: () => void;
+    notifyPreviewClick: (file: any) => void;
+    notifyDrop: (e: any, files: Array<File>, fileList: Array<BaseFileItem>) => void;
+    notifyAcceptInvalid: (invalidFiles: Array<File>) => void;
+}
+declare class UploadFoundation<P = Record<string, any>, S = Record<string, any>> extends BaseFoundation<UploadAdapter<P, S>, P, S> {
+    constructor(adapter: UploadAdapter<P, S>);
+    destroy(): void;
+    getError({ action, xhr, message, fileName }: {
+        action: string;
+        xhr: XMLHttpRequest;
+        message?: string;
+        fileName: string;
+    }): XhrError;
+    getBody(xhr: XMLHttpRequest): any;
+    checkFileSize(file: File): boolean;
+    /**
+     * 1. 选择文件
+     * 2. transform转换. 添加uid
+     * 3. 检查文件个数是否超出
+     *   若超出，不添加到list中，触发onExceed，中止流程
+     *   若未超出，执行以下流程
+     * 4. 检查文件尺寸，添加尺寸是否合法的标识
+     * 5. 检查uploadTrigger是否为'auto'，若是执行步骤6-8
+     * 6. 遍历文件列表触发上传
+     *    - 对尺寸不合适的不需要触发上传
+     * 7. beforeUpload
+     *    - 对beforeUpload中设为不合法的不需要触发上传
+     * 8. TODO: check
+     * 9. afterUpload
+     *
+     * 1. Select file
+     * 2. transform, add uid
+     * 3. Check whether the number of files exceeds
+     *   If it exceeds, it is not added to the list, trigger onExceed, and abort the process
+     *   If it is not exceeded, execute the following process
+     * 4. check the file size, add the size is legal logo
+     * 5. Check whether the uploadTrigger is'auto ', if so, perform steps 6-8
+     * 6. Traversing the file list triggers upload
+     *    - No need to trigger uploads for inappropriate sizes
+     * 7. beforeUpload
+     *    - no need to trigger upload if beforeUpload is not set to be valid
+     * 8. TODO: check
+     * 9. afterUpload
+     */
+    handleChange(currentFileList: FileList | Array<File>): void;
+    handleReplaceChange(currentFileList: FileList | Array<File>): void;
+    buildFileItem(fileInstance: CustomFile, uploadTrigger: string): BaseFileItem;
+    replaceFileList(files: Array<CustomFile>): void;
+    addFilesToList(files: Array<CustomFile>): void;
+    insertFileToList(files: Array<CustomFile>, index: number): void;
+    manualUpload(): void;
+    startUpload(fileList: Array<BaseFileItem>): void;
+    upload(file: BaseFileItem): void;
+    handleBeforeUploadResultInObject(buResult: Partial<BeforeUploadObjectResult>, file: BaseFileItem): void;
+    post(file: BaseFileItem): void;
+    handleProgress({ e, fileInstance }: {
+        e: ProgressEvent;
+        fileInstance: File;
+    }): void;
+    handleOnLoad({ e, xhr, fileInstance }: {
+        e: ProgressEvent;
+        xhr: XMLHttpRequest;
+        fileInstance: File;
+    }): void;
+    handleSuccess({ e, fileInstance, isCustomRequest, xhr, response }: {
+        e: ProgressEvent;
+        fileInstance: CustomFile;
+        isCustomRequest?: boolean;
+        xhr?: XMLHttpRequest;
+        response?: any;
+    }): void;
+    _getFileIndex(file: CustomFile | BaseFileItem, fileList: Array<BaseFileItem>): number;
+    handleRemove(file: BaseFileItem): void;
+    handleError({ e, xhr, fileInstance }: {
+        e: ProgressEvent;
+        xhr: XMLHttpRequest;
+        fileInstance: CustomFile;
+    }): void;
+    handleClear(): void;
+    _createURL(fileInstance: CustomFile): string;
+    releaseMemory(): void;
+    _releaseBlob(url: string): void;
+    isImage(file: CustomFile): boolean;
+    isMultiple(): boolean;
+    _dragEnterTarget: EventTarget;
+    handleDragEnter(e: any): void;
+    handleDirectoryDrop(e: any): Promise<void>;
+    handleDrop(e: any): void;
+    handleDragOver(e: any): void;
+    handleDragLeave(e: any): void;
+    checkFileFormat(accept: string, file: File): boolean;
+    retry(fileItem: BaseFileItem): void;
+    handlePreviewClick(fileItem: BaseFileItem): void;
+}
+export default UploadFoundation;