@reskin/core 0.0.22 → 0.1.0

package/esm2015/utils/form.js

@@ -1,21 +1,52 @@
 /**
  * 表单验证
- * @param form
+ *
+ * 遍历表单所有控件，标记为脏状态并触发验证。
+ * 如果表单验证通过，返回表单的原始值；否则返回 false。
+ *
+ * @param form Angular 表单组对象
+ * @param options 验证配置选项
+ * @returns 验证通过返回表单值，验证失败返回 false
+ *
+ * @example
+ * const result = formVerify(this.form);
+ * if (result) {
+ *   console.log('表单数据:', result);
+ * }
+ *
+ * @example
+ * // 自定义错误处理
+ * formVerify(this.form, {
+ *   logError: false,
+ *   onError: (fields) => {
+ *     this.message.error(`以下字段验证失败: ${fields.join(', ')}`);
+ *   }
+ * });
  */
-export function formVerify(form) {
-    const errList = [];
-    for (const key in form.controls) {
-        form.controls[key].markAsDirty();
-        form.controls[key].updateValueAndValidity();
-        if (form.controls[key].status !== 'VALID' && form.controls[key].status !== 'DISABLED') {
-            errList.push(key);
+export function formVerify(form, options) {
+    const { logError = true, onError } = options || {};
+    const invalidFields = [];
+    // 遍历所有控件，标记为脏状态并更新验证状态
+    Object.keys(form.controls).forEach((key) => {
+        const control = form.controls[key];
+        control.markAsDirty();
+        control.updateValueAndValidity();
+        // 收集验证失败的字段（排除禁用状态）
+        if (control.status !== 'VALID' && control.status !== 'DISABLED') {
+            invalidFields.push(key);
+        }
+    });
+    // 表单验证失败（排除全部禁用的情况）
+    if (form.status !== 'VALID' && form.status !== 'DISABLED') {
+        if (logError) {
+            console.error(`表单验证失败，字段: ${invalidFields.join(', ')}`);
+        }
+        if (onError) {
+            onError(invalidFields);
         }
-    }
-    // 表单验证状态
-    if (form.status !== 'VALID') {
-        console.error(`Form validation failed fields：${errList.join(',')}`);
         return false;
     }
+    // 验证通过，返回表单原始值（包含禁用字段）
     return form.getRawValue();
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZm9ybS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL2xpYnJhcnkvY29yZS91dGlscy9mb3JtLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBOzs7R0FHRztBQUNILE1BQU0sVUFBVSxVQUFVLENBQTBCLElBQWU7SUFDL0QsTUFBTSxPQUFPLEdBQUcsRUFBRSxDQUFDO0lBQ25CLEtBQUssTUFBTSxHQUFHLElBQUksSUFBSSxDQUFDLFFBQVEsRUFBRTtRQUM3QixJQUFJLENBQUMsUUFBUSxDQUFDLEdBQUcsQ0FBQyxDQUFDLFdBQVcsRUFBRSxDQUFDO1FBQ2pDLElBQUksQ0FBQyxRQUFRLENBQUMsR0FBRyxDQUFDLENBQUMsc0JBQXNCLEVBQUUsQ0FBQztRQUM1QyxJQUFJLElBQUksQ0FBQyxRQUFRLENBQUMsR0FBRyxDQUFDLENBQUMsTUFBTSxLQUFLLE9BQU8sSUFBSSxJQUFJLENBQUMsUUFBUSxDQUFDLEdBQUcsQ0FBQyxDQUFDLE1BQU0sS0FBSyxVQUFVLEVBQUU7WUFDbkYsT0FBTyxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQztTQUNyQjtLQUNKO0lBQ0QsU0FBUztJQUNULElBQUksSUFBSSxDQUFDLE1BQU0sS0FBSyxPQUFPLEVBQUU7UUFDekIsT0FBTyxDQUFDLEtBQUssQ0FBQyxpQ0FBaUMsT0FBTyxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsRUFBRSxDQUFDLENBQUM7UUFDcEUsT0FBTyxLQUFLLENBQUM7S0FDaEI7SUFDRCxPQUFPLElBQUksQ0FBQyxXQUFXLEVBQUUsQ0FBQztBQUM5QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRm9ybUdyb3VwIH0gZnJvbSAnQGFuZ3VsYXIvZm9ybXMnO1xyXG5cclxuLyoqXHJcbiAqIOihqOWNlemqjOivgVxyXG4gKiBAcGFyYW0gZm9ybVxyXG4gKi9cclxuZXhwb3J0IGZ1bmN0aW9uIGZvcm1WZXJpZnk8VCA9IFJlY29yZDxzdHJpbmcsIGFueT4+KGZvcm06IEZvcm1Hcm91cCk6IGZhbHNlIHwgVCB7XHJcbiAgICBjb25zdCBlcnJMaXN0ID0gW107XHJcbiAgICBmb3IgKGNvbnN0IGtleSBpbiBmb3JtLmNvbnRyb2xzKSB7XHJcbiAgICAgICAgZm9ybS5jb250cm9sc1trZXldLm1hcmtBc0RpcnR5KCk7XHJcbiAgICAgICAgZm9ybS5jb250cm9sc1trZXldLnVwZGF0ZVZhbHVlQW5kVmFsaWRpdHkoKTtcclxuICAgICAgICBpZiAoZm9ybS5jb250cm9sc1trZXldLnN0YXR1cyAhPT0gJ1ZBTElEJyAmJiBmb3JtLmNvbnRyb2xzW2tleV0uc3RhdHVzICE9PSAnRElTQUJMRUQnKSB7XHJcbiAgICAgICAgICAgIGVyckxpc3QucHVzaChrZXkpO1xyXG4gICAgICAgIH1cclxuICAgIH1cclxuICAgIC8vIOihqOWNlemqjOivgeeKtuaAgVxyXG4gICAgaWYgKGZvcm0uc3RhdHVzICE9PSAnVkFMSUQnKSB7XHJcbiAgICAgICAgY29uc29sZS5lcnJvcihgRm9ybSB2YWxpZGF0aW9uIGZhaWxlZCBmaWVsZHPvvJoke2Vyckxpc3Quam9pbignLCcpfWApO1xyXG4gICAgICAgIHJldHVybiBmYWxzZTtcclxuICAgIH1cclxuICAgIHJldHVybiBmb3JtLmdldFJhd1ZhbHVlKCk7XHJcbn1cclxuIl19
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/utils/store.js

@@ -6,71 +6,146 @@ let prefix = 'SK_';
  * 设置存储前缀
  *
  * 该函数用于更改全局存储前缀，影响后续所有存储操作的键名前缀。
- * 存储前缀的更改可能会影响已存储的数据被正确识别和访问。
+ * 注意：更改前缀后，之前使用旧前缀存储的数据将无法访问。
  *
  * @param newPrefix 新的存储前缀字符串
+ *
+ * @example
+ * setStorePrefix('MY_APP_');
  */
 export function setStorePrefix(newPrefix) {
     prefix = newPrefix;
 }
 /**
- * 提供了一个用于缓存值的类，值可以被存储在浏览器的localStorage或sessionStorage中。
- * 如果提供了过期时间，存储的值会在过期后自动移除。
+ * 提供了一个用于缓存值的类，值可以被存储在浏览器的 localStorage 或 sessionStorage 中。
+ * 支持过期时间设置，过期后数据会自动移除。
+ *
+ * @template T 存储数据的类型
+ *
+ * @example
+ * // 基础用法
+ * const userStore = new Store<User>('user', { name: '', age: 0 });
+ * userStore.set({ name: '张三', age: 25 });
+ * console.log(userStore.get()); // { name: '张三', age: 25 }
+ *
+ * @example
+ * // 使用 localStorage 并设置过期时间
+ * const tokenStore = new Store<string>('token', '', {
+ *   storageEngine: localStorage,
+ *   expires: 3600000 // 1小时后过期
+ * });
  */
 export class Store {
     /**
-     * 初始化Store类的实例。
-     * @param key 缓存值的键名。
-     * @param defaultValue 初始值，默认值会被存储并返回直到设置新的值。
-     * @param options 配置选项，包括存储引擎和过期时间。
+     * 初始化 Store 类的实例
+     * @param key 缓存值的键名
+     * @param defaultValue 初始值，默认值会被存储并返回直到设置新的值
+     * @param options 配置选项，包括存储引擎和过期时间
      */
     constructor(key, defaultValue, options) {
+        this.key = key;
         this.value = defaultValue;
-        // 进行初始设置
-        this.storageKey = () => `@${prefix}_${key}`.toLocaleUpperCase();
         const { storageEngine = sessionStorage, expires } = options !== null && options !== void 0 ? options : {};
         this.storage = storageEngine;
         this.expires = expires;
-        const storedValue = this.storage.getItem(this.storageKey());
-        if (storedValue) {
+        // 尝试从存储中读取数据
+        this.loadFromStorage();
+    }
+    /**
+     * 生成存储键名
+     */
+    getStorageKey() {
+        return `@${prefix}_${this.key}`.toLocaleUpperCase();
+    }
+    /**
+     * 从存储中加载数据
+     */
+    loadFromStorage() {
+        try {
+            const storedValue = this.storage.getItem(this.getStorageKey());
+            if (!storedValue) {
+                return;
+            }
             const { data, expiry } = JSON.parse(storedValue);
-            // 判断是否过期，过期后删除key
+            // 检查是否过期
             if (!expiry || expiry > Date.now()) {
                 this.value = data;
             }
             else {
-                this.storage.removeItem(this.storageKey());
+                // 过期则删除
+                this.clear();
             }
         }
+        catch (error) {
+            console.error(`从存储中读取数据失败 (key: ${this.getStorageKey()}):`, error);
+            // 数据损坏时清除
+            this.clear();
+        }
     }
     /**
-     * 获取当前缓存的值。
-     * @returns 缓存的值。
+     * 获取当前缓存的值
+     * @returns 缓存的值
      */
     get() {
         return this.value;
     }
     /**
-     * 设置新的缓存值。
-     * @param newValue 新的值。
+     * 设置新的缓存值
+     * @param newValue 新的值
      */
     set(newValue) {
         this.value = newValue;
-        // 设置值时进行Storage设置
-        const value = JSON.stringify({
-            data: newValue,
-            expiry: this.expires ? Date.now() + this.expires : null,
-        });
-        this.storage.setItem(this.storageKey(), value);
+        try {
+            const storageData = {
+                data: newValue,
+                expiry: this.expires ? Date.now() + this.expires : null,
+            };
+            this.storage.setItem(this.getStorageKey(), JSON.stringify(storageData));
+        }
+        catch (error) {
+            console.error(`存储数据失败 (key: ${this.getStorageKey()}):`, error);
+        }
     }
     /**
-     * 使用提供的函数更新缓存的值。
-     * @param updateFn 一个接受当前值并返回新值的函数。
+     * 使用提供的函数更新缓存的值
+     * @param updateFn 一个接受当前值并返回新值的函数
+     *
+     * @example
+     * const countStore = new Store<number>('count', 0);
+     * countStore.update(count => count + 1);
      */
     update(updateFn) {
         if (typeof updateFn === 'function') {
             this.set(updateFn(this.value));
         }
     }
+    /**
+     * 清除缓存数据
+     */
+    clear() {
+        try {
+            this.storage.removeItem(this.getStorageKey());
+        }
+        catch (error) {
+            console.error(`清除存储数据失败 (key: ${this.getStorageKey()}):`, error);
+        }
+    }
+    /**
+     * 检查缓存是否存在且未过期
+     * @returns 如果缓存存在且未过期返回 true，否则返回 false
+     */
+    has() {
+        try {
+            const storedValue = this.storage.getItem(this.getStorageKey());
+            if (!storedValue) {
+                return false;
+            }
+            const { expiry } = JSON.parse(storedValue);
+            return !expiry || expiry > Date.now();
+        }
+        catch (_a) {
+            return false;
+        }
+    }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"store.js","sourceRoot":"","sources":["../../../../library/core/utils/store.ts"],"names":[],"mappings":"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","sourcesContent":["/**\r\n * 缓存配置信息\r\n */\r\nexport interface StoreOptions {\r\n    /**\r\n     * 缓存存储方式\r\n     * @default sessionStorage\r\n     */\r\n    storageEngine?: Storage;\r\n    /**\r\n     * 过期时间（毫秒）\r\n     * @default undefined (永不过期)\r\n     */\r\n    expires?: number;\r\n}\r\n\r\n/**\r\n * 存储数据结构\r\n */\r\ninterface StorageData<T> {\r\n    /**\r\n     * 实际存储的数据\r\n     */\r\n    data: T;\r\n    /**\r\n     * 过期时间戳（毫秒）\r\n     */\r\n    expiry: number | null;\r\n}\r\n\r\n/**\r\n * 默认前缀\r\n */\r\nlet prefix: string = 'SK_';\r\n\r\n/**\r\n * 设置存储前缀\r\n *\r\n * 该函数用于更改全局存储前缀，影响后续所有存储操作的键名前缀。\r\n * 注意：更改前缀后，之前使用旧前缀存储的数据将无法访问。\r\n *\r\n * @param newPrefix 新的存储前缀字符串\r\n *\r\n * @example\r\n * setStorePrefix('MY_APP_');\r\n */\r\nexport function setStorePrefix(newPrefix: string): void {\r\n    prefix = newPrefix;\r\n}\r\n\r\n/**\r\n * 提供了一个用于缓存值的类，值可以被存储在浏览器的 localStorage 或 sessionStorage 中。\r\n * 支持过期时间设置，过期后数据会自动移除。\r\n *\r\n * @template T 存储数据的类型\r\n *\r\n * @example\r\n * // 基础用法\r\n * const userStore = new Store<User>('user', { name: '', age: 0 });\r\n * userStore.set({ name: '张三', age: 25 });\r\n * console.log(userStore.get()); // { name: '张三', age: 25 }\r\n *\r\n * @example\r\n * // 使用 localStorage 并设置过期时间\r\n * const tokenStore = new Store<string>('token', '', {\r\n *   storageEngine: localStorage,\r\n *   expires: 3600000 // 1小时后过期\r\n * });\r\n */\r\nexport class Store<T> {\r\n    private value: T;\r\n    private readonly storage: Storage;\r\n    private readonly expires?: number;\r\n    private readonly key: string;\r\n\r\n    /**\r\n     * 初始化 Store 类的实例\r\n     * @param key 缓存值的键名\r\n     * @param defaultValue 初始值，默认值会被存储并返回直到设置新的值\r\n     * @param options 配置选项，包括存储引擎和过期时间\r\n     */\r\n    constructor(key: string, defaultValue: T, options?: StoreOptions) {\r\n        this.key = key;\r\n        this.value = defaultValue;\r\n\r\n        const { storageEngine = sessionStorage, expires } = options ?? {};\r\n        this.storage = storageEngine;\r\n        this.expires = expires;\r\n\r\n        // 尝试从存储中读取数据\r\n        this.loadFromStorage();\r\n    }\r\n\r\n    /**\r\n     * 生成存储键名\r\n     */\r\n    private getStorageKey(): string {\r\n        return `@${prefix}_${this.key}`.toLocaleUpperCase();\r\n    }\r\n\r\n    /**\r\n     * 从存储中加载数据\r\n     */\r\n    private loadFromStorage(): void {\r\n        try {\r\n            const storedValue = this.storage.getItem(this.getStorageKey());\r\n            if (!storedValue) {\r\n                return;\r\n            }\r\n\r\n            const { data, expiry } = JSON.parse(storedValue) as StorageData<T>;\r\n\r\n            // 检查是否过期\r\n            if (!expiry || expiry > Date.now()) {\r\n                this.value = data;\r\n            } else {\r\n                // 过期则删除\r\n                this.clear();\r\n            }\r\n        } catch (error) {\r\n            console.error(`从存储中读取数据失败 (key: ${this.getStorageKey()}):`, error);\r\n            // 数据损坏时清除\r\n            this.clear();\r\n        }\r\n    }\r\n\r\n    /**\r\n     * 获取当前缓存的值\r\n     * @returns 缓存的值\r\n     */\r\n    get(): T {\r\n        return this.value;\r\n    }\r\n\r\n    /**\r\n     * 设置新的缓存值\r\n     * @param newValue 新的值\r\n     */\r\n    set(newValue: T): void {\r\n        this.value = newValue;\r\n\r\n        try {\r\n            const storageData: StorageData<T> = {\r\n                data: newValue,\r\n                expiry: this.expires ? Date.now() + this.expires : null,\r\n            };\r\n            this.storage.setItem(this.getStorageKey(), JSON.stringify(storageData));\r\n        } catch (error) {\r\n            console.error(`存储数据失败 (key: ${this.getStorageKey()}):`, error);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * 使用提供的函数更新缓存的值\r\n     * @param updateFn 一个接受当前值并返回新值的函数\r\n     *\r\n     * @example\r\n     * const countStore = new Store<number>('count', 0);\r\n     * countStore.update(count => count + 1);\r\n     */\r\n    update(updateFn: (currentValue: T) => T): void {\r\n        if (typeof updateFn === 'function') {\r\n            this.set(updateFn(this.value));\r\n        }\r\n    }\r\n\r\n    /**\r\n     * 清除缓存数据\r\n     */\r\n    clear(): void {\r\n        try {\r\n            this.storage.removeItem(this.getStorageKey());\r\n        } catch (error) {\r\n            console.error(`清除存储数据失败 (key: ${this.getStorageKey()}):`, error);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * 检查缓存是否存在且未过期\r\n     * @returns 如果缓存存在且未过期返回 true，否则返回 false\r\n     */\r\n    has(): boolean {\r\n        try {\r\n            const storedValue = this.storage.getItem(this.getStorageKey());\r\n            if (!storedValue) {\r\n                return false;\r\n            }\r\n\r\n            const { expiry } = JSON.parse(storedValue) as StorageData<T>;\r\n            return !expiry || expiry > Date.now();\r\n        } catch {\r\n            return false;\r\n        }\r\n    }\r\n}\r\n"]}