@chatbi-v/core 2.1.10 → 3.1.1

package/dist/chunk-AAKBSVX6.mjs

@@ -0,0 +1,220 @@
+// src/manifest/PluginManifest.ts
+import { z } from "zod";
+var EXTENSION_TYPES = ["slot", "hook", "command", "service"];
+var RENDER_MODES = ["replace", "append", "prepend"];
+var ExtensionSchema = z.object({
+  /** 扩展点名称/标识符 */
+  name: z.string().min(1, "\u6269\u5C55\u70B9\u540D\u79F0\u4E0D\u80FD\u4E3A\u7A7A"),
+  /** 扩展点类型 */
+  type: z.enum(EXTENSION_TYPES),
+  /** 扩展点描述 */
+  description: z.string().optional(),
+  /** 对于 slot 类型，指定插槽位置 */
+  slot: z.string().optional(),
+  /** 扩展点的配置选项 */
+  config: z.record(z.any()).optional(),
+  /**
+   * 渲染模式
+   * @description 定义插槽内容的渲染方式：replace(替换)、append(追加)、prepend(前置)
+   */
+  renderMode: z.enum(RENDER_MODES).optional(),
+  /**
+   * 条件渲染配置
+   * @description 用于条件渲染，如 requiresAuth: true 表示需要认证
+   */
+  condition: z.record(z.any()).optional()
+});
+var DependencySchema = z.object({
+  /** 依赖插件 ID */
+  id: z.string().min(1, "\u4F9D\u8D56\u63D2\u4EF6 ID \u4E0D\u80FD\u4E3A\u7A7A"),
+  /** 依赖版本范围 (SemVer) */
+  version: z.string().min(1, "\u4F9D\u8D56\u7248\u672C\u4E0D\u80FD\u4E3A\u7A7A"),
+  /** 是否为可选依赖 */
+  optional: z.boolean().optional().default(false)
+});
+var PLUGIN_TYPES = [
+  "business",
+  "functional",
+  "view",
+  "theme",
+  "renderer",
+  "system"
+];
+var EntrySchema = z.union([
+  z.string().min(1, "\u5165\u53E3\u8DEF\u5F84\u4E0D\u80FD\u4E3A\u7A7A"),
+  z.object({
+    /** 入口文件 URL */
+    url: z.string().min(1, "\u5165\u53E3 URL \u4E0D\u80FD\u4E3A\u7A7A"),
+    /** 共享作用域 (用于模块联邦) */
+    shareScope: z.string().optional()
+  })
+]);
+var CompatibilitySchema = z.object({
+  /** 最低宿主版本 */
+  minVersion: z.string().optional(),
+  /** 最高宿主版本 */
+  maxVersion: z.string().optional(),
+  /** 兼容的宿主版本列表 */
+  supportedVersions: z.array(z.string()).optional()
+});
+var CapabilitiesSchema = z.record(z.boolean());
+var ConfigurationSchema = z.array(
+  z.object({
+    key: z.string().min(1),
+    type: z.enum(["string", "number", "boolean", "select"]),
+    label: z.string().min(1),
+    description: z.string().optional(),
+    default: z.any().optional(),
+    options: z.array(z.object({ label: z.string(), value: z.any() })).optional()
+  })
+);
+var PERMISSION_ACTIONS = [
+  "read",
+  "write",
+  "execute",
+  "admin"
+];
+var PERMISSION_SCOPES = ["plugin", "global", "user"];
+var PluginManifestSchema = z.object({
+  /** 插件唯一 ID (推荐反向域名格式) */
+  id: z.string().min(1, "\u63D2\u4EF6 ID \u4E0D\u80FD\u4E3A\u7A7A"),
+  /** 插件版本号 (SemVer) */
+  version: z.string().min(1, "\u7248\u672C\u53F7\u4E0D\u80FD\u4E3A\u7A7A").refine((v) => /^\d+\.\d+\.\d+(-[a-zA-Z0-9.-]+)?$/.test(v), {
+    message: "\u7248\u672C\u53F7\u5FC5\u987B\u7B26\u5408 SemVer \u683C\u5F0F"
+  }),
+  /** 插件显示名称 */
+  name: z.string().min(1, "\u63D2\u4EF6\u540D\u79F0\u4E0D\u80FD\u4E3A\u7A7A"),
+  /** 插件入口 */
+  entry: EntrySchema,
+  /** 插件类型 */
+  type: z.enum(PLUGIN_TYPES).optional().default("business"),
+  /** 插件功能描述 */
+  description: z.string().optional(),
+  /** 插件作者 */
+  author: z.string().optional(),
+  /** 插件图标 */
+  icon: z.string().optional(),
+  /** 兼容性要求 */
+  compatibility: CompatibilitySchema.optional(),
+  /** 插件依赖 */
+  dependencies: z.array(DependencySchema).optional().default([]),
+  /** 扩展点声明 */
+  extensions: z.array(ExtensionSchema).optional().default([]),
+  /** 能力声明 */
+  capabilities: CapabilitiesSchema.optional(),
+  /** 配置项定义 */
+  configuration: ConfigurationSchema.optional(),
+  /** 存储定义 */
+  storage: z.array(z.any()).optional(),
+  /** 路由定义 (仅供展示，实际路由在运行时注册) */
+  routes: z.array(z.object({ path: z.string() })).optional(),
+  /** 权限声明 */
+  permissions: z.array(
+    z.object({
+      action: z.enum(PERMISSION_ACTIONS),
+      scope: z.enum(PERMISSION_SCOPES),
+      resource: z.string()
+    })
+  ).optional(),
+  /** 插件优先级 */
+  priority: z.number().optional().default(100)
+});
+
+// src/manifest/ManifestValidator.ts
+function formatZodErrors(error) {
+  return error.errors.map((err) => ({
+    message: err.message,
+    path: err.path.map(String),
+    type: err.code
+  }));
+}
+function validateManifest(raw) {
+  const result = PluginManifestSchema.safeParse(raw);
+  if (result.success) {
+    return {
+      valid: true,
+      data: result.data
+    };
+  }
+  return {
+    valid: false,
+    errors: formatZodErrors(result.error)
+  };
+}
+function assertManifest(raw) {
+  return PluginManifestSchema.parse(raw);
+}
+
+// src/manifest/ManifestWrapper.ts
+function extractManifestFromPlugin(plugin) {
+  const input = plugin;
+  const metadata = input.metadata;
+  const manifest = {
+    id: input.id || metadata?.id,
+    version: metadata?.version || "1.0.0",
+    name: metadata?.name || input.name,
+    type: metadata?.type || input.type,
+    description: metadata?.description || input.description,
+    author: metadata?.author || input.author,
+    icon: metadata?.icon || input.icon,
+    entry: input.entry || "index.js"
+  };
+  const deps = metadata?.dependencies || input.dependencies;
+  if (Array.isArray(deps)) {
+    manifest.dependencies = deps.map((dep) => {
+      if (typeof dep === "string") {
+        return { id: dep, version: "*", optional: false };
+      }
+      return dep;
+    });
+  }
+  const extensions = metadata?.extensions || input.extensions;
+  if (Array.isArray(extensions)) {
+    manifest.extensions = extensions.map(
+      (ext) => ({
+        name: ext.slot || ext.name,
+        type: "slot",
+        description: ext.meta?.description,
+        slot: ext.slot
+      })
+    );
+  }
+  const caps = metadata?.capabilities || input.capabilities;
+  if (caps && typeof caps === "object") {
+    manifest.capabilities = caps;
+  }
+  const config = metadata?.configuration || input.configuration;
+  if (Array.isArray(config)) {
+    manifest.configuration = config;
+  }
+  return manifest;
+}
+function normalizePluginManifest(input) {
+  let manifest;
+  if (!input || typeof input !== "object") {
+    return {
+      valid: false,
+      errors: [{ message: "\u8F93\u5165\u5FC5\u987B\u662F\u5BF9\u8C61", path: [], type: "invalid_type" }]
+    };
+  }
+  const record = input;
+  if (record.id && record.version && record.name && record.entry) {
+    manifest = record;
+  } else if (record.metadata) {
+    manifest = extractManifestFromPlugin(record);
+  } else {
+    manifest = extractManifestFromPlugin(record);
+  }
+  return validateManifest(manifest);
+}
+
+export {
+  EXTENSION_TYPES,
+  RENDER_MODES,
+  PLUGIN_TYPES,
+  PluginManifestSchema,
+  validateManifest,
+  assertManifest,
+  extractManifestFromPlugin,
+  normalizePluginManifest
+};

package/dist/chunk-K6BVKKI6.mjs

@@ -0,0 +1,184 @@
+// src/adapters/AdapterInterface.ts
+var BaseAdapter = class {
+  /**
+   * 模板方法 - 三层变换默认实现
+   * primitives -> semantics -> component tokens
+   */
+  transformTokens(tokens, options) {
+    const semantics = options?.colorScheme === "dark" && tokens.semanticsDark ? tokens.semanticsDark : tokens.semantics;
+    return this.semanticsToComponents(semantics, options);
+  }
+  /**
+   * 将语义 Token 转换为组件级别配置
+   * 由子类实现具体转换逻辑
+   */
+  semanticsToComponents(semantics, options) {
+    return {};
+  }
+  transform(tokens, options) {
+    return this.transformTokens(tokens, options);
+  }
+};
+
+// src/adapters/AdapterRegistry.ts
+var AdapterRegistry = class {
+  adapters = /* @__PURE__ */ new Map();
+  states = /* @__PURE__ */ new Map();
+  activeAdapterId = null;
+  currentTokens = {};
+  /**
+   * 注册适配器
+   * @param adapter 要注册的 UIAdapter 实例
+   */
+  register(adapter) {
+    if (this.adapters.has(adapter.id)) {
+      console.warn(
+        `[AdapterRegistry] Adapter ${adapter.id} already registered, overwriting`
+      );
+    }
+    this.adapters.set(adapter.id, adapter);
+    this.states.set(adapter.id, {
+      adapter,
+      status: "registered",
+      registeredAt: /* @__PURE__ */ new Date()
+    });
+  }
+  /**
+   * 注销适配器
+   * @param adapterId 要注销的适配器 ID
+   * @returns 是否成功注销
+   */
+  unregister(adapterId) {
+    if (this.activeAdapterId === adapterId) {
+      console.warn(
+        `[AdapterRegistry] Cannot unregister active adapter ${adapterId}`
+      );
+      return false;
+    }
+    const adapter = this.adapters.get(adapterId);
+    if (adapter) {
+      adapter.remove();
+    }
+    this.adapters.delete(adapterId);
+    this.states.delete(adapterId);
+    return true;
+  }
+  /**
+   * 获取指定适配器
+   * @param adapterId 适配器 ID
+   * @returns 适配器实例或 undefined
+   */
+  get(adapterId) {
+    return this.adapters.get(adapterId);
+  }
+  /**
+   * 获取所有已注册的适配器
+   * @returns 所有适配器实例数组
+   */
+  getAll() {
+    return Array.from(this.adapters.values());
+  }
+  /**
+   * 获取所有适配器状态
+   * @returns 所有适配器状态数组
+   */
+  getAllStates() {
+    return Array.from(this.states.values());
+  }
+  /**
+   * 设置活跃适配器
+   * @param adapterId 要激活的适配器 ID
+   * @returns 是否成功激活
+   */
+  setActive(adapterId) {
+    const adapter = this.adapters.get(adapterId);
+    if (!adapter) {
+      console.error(`[AdapterRegistry] Adapter ${adapterId} not found`);
+      return false;
+    }
+    if (this.activeAdapterId) {
+      const current = this.adapters.get(this.activeAdapterId);
+      current?.remove();
+      this.updateState(this.activeAdapterId, "inactive");
+    }
+    const transformedTheme = adapter.transform(this.currentTokens);
+    adapter.apply(transformedTheme);
+    this.activeAdapterId = adapterId;
+    this.updateState(adapterId, "active");
+    return true;
+  }
+  /**
+   * 获取当前活跃适配器
+   * @returns 活跃适配器实例或 undefined
+   */
+  getActive() {
+    return this.activeAdapterId ? this.adapters.get(this.activeAdapterId) : void 0;
+  }
+  /**
+   * 使用当前活跃适配器转换 Token
+   * @param tokens DesignSystem Token
+   * @param options 转换选项
+   * @returns 转换后的主题配置
+   */
+  transform(tokens, options) {
+    const adapter = this.getActive();
+    if (!adapter) {
+      console.warn("[AdapterRegistry] No active adapter, returning raw tokens");
+      return tokens;
+    }
+    return adapter.transform(tokens, options);
+  }
+  /**
+   * 检查是否支持指定目标库
+   * @param targetLibrary 目标库标识
+   * @returns 是否支持
+   */
+  supports(targetLibrary) {
+    return Array.from(this.adapters.values()).some(
+      (adapter) => adapter.targetLibrary === targetLibrary
+    );
+  }
+  /**
+   * 获取支持指定目标库的所有适配器
+   * @param targetLibrary 目标库标识
+   * @returns 适配器数组
+   */
+  getAdaptersForTarget(targetLibrary) {
+    return this.getAll().filter(
+      (adapter) => adapter.targetLibrary === targetLibrary
+    );
+  }
+  /**
+   * 设置当前 DesignSystem Token
+   * @param tokens DesignSystem 实例
+   */
+  setTokens(tokens) {
+    this.currentTokens = tokens;
+  }
+  /**
+   * 获取当前 DesignSystem Token
+   * @returns 当前 Token
+   */
+  getTokens() {
+    return this.currentTokens;
+  }
+  /**
+   * 内部方法 - 更新适配器状态
+   */
+  updateState(adapterId, status) {
+    const state = this.states.get(adapterId);
+    if (state) {
+      state.status = status;
+      if (status === "active") {
+        state.activatedAt = /* @__PURE__ */ new Date();
+      }
+    }
+  }
+};
+var adapterRegistry = new AdapterRegistry();
+
+export {
+  BaseAdapter,
+  AdapterRegistry,
+  adapterRegistry
+};