@nokecy/qc-ui 1.0.66 → 1.0.67

package/dist/esm/components/RegexEditor/templates/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 模板系统统一导出
+ */
+export type { RegexTemplate } from './types';
+export { TemplateCategory } from './types';
+export { getAllBuiltinTemplates, getTemplatesByCategory as getBuiltinTemplatesByCategory, getTemplateById as getBuiltinTemplateById, searchTemplates as searchBuiltinTemplates, } from './builtinTemplates';
+export { TemplateStorage, loadCustomTemplates, saveCustomTemplate, deleteCustomTemplate, updateTemplateUsage, clearAllTemplates, exportTemplates, importTemplates, getStorageStats, isStorageAvailable, } from './storage';
+export { getAllTemplates, getTemplateById, getTemplatesByCategory, searchTemplates, getMostUsedTemplates, getRecentlyUsedTemplates, createCustomTemplate, updateCustomTemplate, deleteCustomTemplate as deleteCustomTemplateById, duplicateTemplate, useTemplate, getTemplateStats, validateTemplate, } from './templateManager';
+export { TemplateSelector } from './TemplateSelector';
+export type { TemplateSelectorProps } from './TemplateSelector';

package/dist/esm/components/RegexEditor/templates/index.js

@@ -0,0 +1,19 @@
+/**
+ * 模板系统统一导出
+ */
+
+// 类型定义
+
+export { TemplateCategory } from "./types";
+
+// 内置模板
+export { getAllBuiltinTemplates, getTemplatesByCategory as getBuiltinTemplatesByCategory, getTemplateById as getBuiltinTemplateById, searchTemplates as searchBuiltinTemplates } from "./builtinTemplates";
+
+// 存储层
+export { TemplateStorage, loadCustomTemplates, saveCustomTemplate, deleteCustomTemplate, updateTemplateUsage, clearAllTemplates, exportTemplates, importTemplates, getStorageStats, isStorageAvailable } from "./storage";
+
+// 管理层
+export { getAllTemplates, getTemplateById, getTemplatesByCategory, searchTemplates, getMostUsedTemplates, getRecentlyUsedTemplates, createCustomTemplate, updateCustomTemplate, deleteCustomTemplate as deleteCustomTemplateById, duplicateTemplate, useTemplate, getTemplateStats, validateTemplate } from "./templateManager";
+
+// UI 组件
+export { TemplateSelector } from "./TemplateSelector";

package/dist/esm/components/RegexEditor/templates/storage.d.ts

@@ -0,0 +1,74 @@
+/**
+ * 自定义模板存储模块
+ * 使用 LocalStorage 持久化存储用户自定义的正则表达式模板
+ */
+import type { RegexTemplate } from './types';
+/**
+ * 模板存储工具类
+ */
+export declare class TemplateStorage {
+    /**
+     * 加载所有自定义模板
+     */
+    static loadCustomTemplates(): RegexTemplate[];
+    /**
+     * 保存自定义模板
+     */
+    static saveCustomTemplate(template: RegexTemplate): boolean;
+    /**
+     * 更新模板使用统计
+     */
+    static updateTemplateUsage(templateId: string): boolean;
+    /**
+     * 删除自定义模板
+     */
+    static deleteCustomTemplate(templateId: string): boolean;
+    /**
+     * 批量删除自定义模板
+     */
+    static deleteMultipleTemplates(templateIds: string[]): boolean;
+    /**
+     * 清空所有自定义模板
+     */
+    static clearAllTemplates(): boolean;
+    /**
+     * 导出所有自定义模板为 JSON
+     */
+    static exportTemplates(): string;
+    /**
+     * 从 JSON 导入自定义模板
+     */
+    static importTemplates(jsonString: string, merge?: boolean): boolean;
+    /**
+     * 获取存储统计信息
+     */
+    static getStorageStats(): {
+        count: number;
+        size: number;
+        lastModified: string | null;
+    };
+    /**
+     * 内部方法: 持久化模板数据到 LocalStorage
+     */
+    private static _persistTemplates;
+    /**
+     * 检查 LocalStorage 是否可用
+     */
+    static isStorageAvailable(): boolean;
+}
+/**
+ * 便捷函数导出
+ */
+export declare const loadCustomTemplates: () => RegexTemplate[];
+export declare const saveCustomTemplate: (template: RegexTemplate) => boolean;
+export declare const deleteCustomTemplate: (templateId: string) => boolean;
+export declare const updateTemplateUsage: (templateId: string) => boolean;
+export declare const clearAllTemplates: () => boolean;
+export declare const exportTemplates: () => string;
+export declare const importTemplates: (jsonString: string, merge?: boolean) => boolean;
+export declare const getStorageStats: () => {
+    count: number;
+    size: number;
+    lastModified: string | null;
+};
+export declare const isStorageAvailable: () => boolean;

package/dist/esm/components/RegexEditor/templates/storage.js

@@ -0,0 +1,335 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+/**
+ * 自定义模板存储模块
+ * 使用 LocalStorage 持久化存储用户自定义的正则表达式模板
+ */
+
+import { TemplateCategory } from "./types";
+var STORAGE_KEY = 'regex_editor_custom_templates';
+var STORAGE_VERSION = '1.0';
+/**
+ * 模板存储工具类
+ */
+export var TemplateStorage = /*#__PURE__*/function () {
+  function TemplateStorage() {
+    _classCallCheck(this, TemplateStorage);
+  }
+  _createClass(TemplateStorage, null, [{
+    key: "loadCustomTemplates",
+    value:
+    /**
+     * 加载所有自定义模板
+     */
+    function loadCustomTemplates() {
+      try {
+        var data = localStorage.getItem(STORAGE_KEY);
+        if (!data) {
+          return [];
+        }
+        var parsed = JSON.parse(data);
+
+        // 版本检查
+        if (parsed.version !== STORAGE_VERSION) {
+          console.warn('模板存储版本不匹配,将清空旧数据');
+          this.clearAllTemplates();
+          return [];
+        }
+
+        // 恢复 Date 对象
+        return parsed.templates.map(function (t) {
+          return _objectSpread(_objectSpread({}, t), {}, {
+            lastUsed: t.lastUsed ? new Date(t.lastUsed) : undefined,
+            isCustom: true // 确保标记为自定义模板
+          });
+        });
+      } catch (error) {
+        console.error('加载自定义模板失败:', error);
+        return [];
+      }
+    }
+
+    /**
+     * 保存自定义模板
+     */
+  }, {
+    key: "saveCustomTemplate",
+    value: function saveCustomTemplate(template) {
+      try {
+        var templates = this.loadCustomTemplates();
+
+        // 检查是否已存在
+        var existingIndex = templates.findIndex(function (t) {
+          return t.id === template.id;
+        });
+        if (existingIndex >= 0) {
+          // 更新现有模板
+          templates[existingIndex] = _objectSpread(_objectSpread({}, template), {}, {
+            isCustom: true
+          });
+        } else {
+          // 添加新模板
+          templates.push(_objectSpread(_objectSpread({}, template), {}, {
+            isCustom: true,
+            category: template.category || TemplateCategory.CUSTOM
+          }));
+        }
+        this._persistTemplates(templates);
+        return true;
+      } catch (error) {
+        console.error('保存自定义模板失败:', error);
+        return false;
+      }
+    }
+
+    /**
+     * 更新模板使用统计
+     */
+  }, {
+    key: "updateTemplateUsage",
+    value: function updateTemplateUsage(templateId) {
+      try {
+        var templates = this.loadCustomTemplates();
+        var template = templates.find(function (t) {
+          return t.id === templateId;
+        });
+        if (!template) {
+          return false;
+        }
+        template.useCount = (template.useCount || 0) + 1;
+        template.lastUsed = new Date();
+        this._persistTemplates(templates);
+        return true;
+      } catch (error) {
+        console.error('更新模板使用统计失败:', error);
+        return false;
+      }
+    }
+
+    /**
+     * 删除自定义模板
+     */
+  }, {
+    key: "deleteCustomTemplate",
+    value: function deleteCustomTemplate(templateId) {
+      try {
+        var templates = this.loadCustomTemplates();
+        var filteredTemplates = templates.filter(function (t) {
+          return t.id !== templateId;
+        });
+        if (filteredTemplates.length === templates.length) {
+          // 未找到要删除的模板
+          return false;
+        }
+        this._persistTemplates(filteredTemplates);
+        return true;
+      } catch (error) {
+        console.error('删除自定义模板失败:', error);
+        return false;
+      }
+    }
+
+    /**
+     * 批量删除自定义模板
+     */
+  }, {
+    key: "deleteMultipleTemplates",
+    value: function deleteMultipleTemplates(templateIds) {
+      try {
+        var templates = this.loadCustomTemplates();
+        var idSet = new Set(templateIds);
+        var filteredTemplates = templates.filter(function (t) {
+          return !idSet.has(t.id);
+        });
+        this._persistTemplates(filteredTemplates);
+        return true;
+      } catch (error) {
+        console.error('批量删除自定义模板失败:', error);
+        return false;
+      }
+    }
+
+    /**
+     * 清空所有自定义模板
+     */
+  }, {
+    key: "clearAllTemplates",
+    value: function clearAllTemplates() {
+      try {
+        localStorage.removeItem(STORAGE_KEY);
+        return true;
+      } catch (error) {
+        console.error('清空自定义模板失败:', error);
+        return false;
+      }
+    }
+
+    /**
+     * 导出所有自定义模板为 JSON
+     */
+  }, {
+    key: "exportTemplates",
+    value: function exportTemplates() {
+      var templates = this.loadCustomTemplates();
+      var data = {
+        version: STORAGE_VERSION,
+        templates: templates,
+        lastModified: new Date().toISOString()
+      };
+      return JSON.stringify(data, null, 2);
+    }
+
+    /**
+     * 从 JSON 导入自定义模板
+     */
+  }, {
+    key: "importTemplates",
+    value: function importTemplates(jsonString) {
+      var merge = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+      try {
+        var data = JSON.parse(jsonString);
+
+        // 版本检查
+        if (data.version !== STORAGE_VERSION) {
+          throw new Error("\u4E0D\u652F\u6301\u7684\u6A21\u677F\u7248\u672C: ".concat(data.version));
+        }
+
+        // 验证模板格式
+        if (!Array.isArray(data.templates)) {
+          throw new Error('无效的模板数据格式');
+        }
+        var templates = data.templates.map(function (t) {
+          return _objectSpread(_objectSpread({}, t), {}, {
+            isCustom: true,
+            lastUsed: t.lastUsed ? new Date(t.lastUsed) : undefined
+          });
+        });
+        if (merge) {
+          // 合并模式: 与现有模板合并
+          var existingTemplates = this.loadCustomTemplates();
+          var existingIds = new Set(existingTemplates.map(function (t) {
+            return t.id;
+          }));
+
+          // 过滤掉 ID 重复的模板
+          var newTemplates = templates.filter(function (t) {
+            return !existingIds.has(t.id);
+          });
+          templates = [].concat(_toConsumableArray(existingTemplates), _toConsumableArray(newTemplates));
+        }
+        this._persistTemplates(templates);
+        return true;
+      } catch (error) {
+        console.error('导入自定义模板失败:', error);
+        return false;
+      }
+    }
+
+    /**
+     * 获取存储统计信息
+     */
+  }, {
+    key: "getStorageStats",
+    value: function getStorageStats() {
+      try {
+        var data = localStorage.getItem(STORAGE_KEY);
+        if (!data) {
+          return {
+            count: 0,
+            size: 0,
+            lastModified: null
+          };
+        }
+        var parsed = JSON.parse(data);
+        return {
+          count: parsed.templates.length,
+          size: new Blob([data]).size,
+          lastModified: parsed.lastModified
+        };
+      } catch (error) {
+        console.error('获取存储统计失败:', error);
+        return {
+          count: 0,
+          size: 0,
+          lastModified: null
+        };
+      }
+    }
+
+    /**
+     * 内部方法: 持久化模板数据到 LocalStorage
+     */
+  }, {
+    key: "_persistTemplates",
+    value: function _persistTemplates(templates) {
+      var data = {
+        version: STORAGE_VERSION,
+        templates: templates,
+        lastModified: new Date().toISOString()
+      };
+      localStorage.setItem(STORAGE_KEY, JSON.stringify(data));
+    }
+
+    /**
+     * 检查 LocalStorage 是否可用
+     */
+  }, {
+    key: "isStorageAvailable",
+    value: function isStorageAvailable() {
+      try {
+        var testKey = '__test_storage__';
+        localStorage.setItem(testKey, 'test');
+        localStorage.removeItem(testKey);
+        return true;
+      } catch (error) {
+        return false;
+      }
+    }
+  }]);
+  return TemplateStorage;
+}();
+
+/**
+ * 便捷函数导出
+ */
+
+export var loadCustomTemplates = function loadCustomTemplates() {
+  return TemplateStorage.loadCustomTemplates();
+};
+export var saveCustomTemplate = function saveCustomTemplate(template) {
+  return TemplateStorage.saveCustomTemplate(template);
+};
+export var deleteCustomTemplate = function deleteCustomTemplate(templateId) {
+  return TemplateStorage.deleteCustomTemplate(templateId);
+};
+export var updateTemplateUsage = function updateTemplateUsage(templateId) {
+  return TemplateStorage.updateTemplateUsage(templateId);
+};
+export var clearAllTemplates = function clearAllTemplates() {
+  return TemplateStorage.clearAllTemplates();
+};
+export var exportTemplates = function exportTemplates() {
+  return TemplateStorage.exportTemplates();
+};
+export var importTemplates = function importTemplates(jsonString, merge) {
+  return TemplateStorage.importTemplates(jsonString, merge);
+};
+export var getStorageStats = function getStorageStats() {
+  return TemplateStorage.getStorageStats();
+};
+export var isStorageAvailable = function isStorageAvailable() {
+  return TemplateStorage.isStorageAvailable();
+};

package/dist/esm/components/RegexEditor/templates/templateManager.d.ts

@@ -0,0 +1,67 @@
+/**
+ * 模板管理器
+ * 统一管理内置模板和自定义模板
+ */
+import type { RegexTemplate } from './types';
+import { TemplateCategory } from './types';
+/**
+ * 获取所有模板(内置 + 自定义)
+ */
+export declare const getAllTemplates: () => RegexTemplate[];
+/**
+ * 根据 ID 获取模板(优先查找自定义模板)
+ */
+export declare const getTemplateById: (id: string) => RegexTemplate | undefined;
+/**
+ * 根据分类获取模板
+ */
+export declare const getTemplatesByCategory: (category: TemplateCategory) => RegexTemplate[];
+/**
+ * 搜索模板(支持关键词搜索)
+ */
+export declare const searchTemplates: (keyword: string) => RegexTemplate[];
+/**
+ * 获取最常用的模板
+ */
+export declare const getMostUsedTemplates: (limit?: number) => RegexTemplate[];
+/**
+ * 获取最近使用的模板
+ */
+export declare const getRecentlyUsedTemplates: (limit?: number) => RegexTemplate[];
+/**
+ * 创建新的自定义模板
+ */
+export declare const createCustomTemplate: (template: Omit<RegexTemplate, 'id' | 'isCustom' | 'useCount' | 'lastUsed'>) => RegexTemplate;
+/**
+ * 更新自定义模板
+ */
+export declare const updateCustomTemplate: (id: string, updates: Partial<Omit<RegexTemplate, 'id' | 'isCustom'>>) => boolean;
+/**
+ * 删除自定义模板
+ */
+export declare const deleteCustomTemplate: (id: string) => boolean;
+/**
+ * 复制模板(创建副本)
+ */
+export declare const duplicateTemplate: (id: string, newName?: string) => RegexTemplate | null;
+/**
+ * 使用模板(更新使用统计)
+ */
+export declare const useTemplate: (id: string) => RegexTemplate | undefined;
+/**
+ * 获取模板统计信息
+ */
+export declare const getTemplateStats: () => {
+    total: number;
+    builtin: number;
+    custom: number;
+    byCategory: Record<TemplateCategory, number>;
+    byComplexity: Record<'simple' | 'medium' | 'complex', number>;
+};
+/**
+ * 验证模板是否有效
+ */
+export declare const validateTemplate: (template: Partial<RegexTemplate>) => {
+    valid: boolean;
+    errors: string[];
+};