@idooel/components 0.0.2-beta.3 → 0.0.2-beta.30

package/packages/utils/runtime-context/globalDataPool.js

@@ -0,0 +1,279 @@
+import { createDataPool } from '@idooel/runtime-context'
+import { TREE_TABLE_FIELDS, getFieldDefaults, validateFieldType, getSupportedFields } from './modelSchema.js'
+
+/**
+ * 全局数据池管理器
+ * 挂载到 window.__idooel_data_pool__，提供统一的数据和实例方法管理
+ */
+
+class BaseModelMethods {
+  constructor(instanceId, dataPool) {
+    this.instanceId = instanceId
+    this.dataPool = dataPool
+  }
+
+  // 基础数据操作 - 保留，实际在使用
+  setData(key, value) {
+    // 验证字段类型（可选）
+    const supportedFields = getSupportedFields()
+    if (supportedFields.includes(key)) {
+      const fieldDef = TREE_TABLE_FIELDS[key]
+      if (fieldDef && !validateFieldType(value, fieldDef.type)) {
+        console.warn(`Field type mismatch for ${key}: expected ${fieldDef.type}, got ${typeof value}`)
+      }
+    }
+    
+    this.dataPool.manager.setData(this.instanceId, key, value)
+    return this
+  }
+
+  getData(key, defaultValue = null) {
+    return this.dataPool.manager.getData(this.instanceId, key, defaultValue)
+  }
+
+  // 事件订阅 - 保留，实际在使用
+  subscribe(key, callback) {
+    return this.dataPool.manager.subscribe({
+      instanceId: this.instanceId,
+      key
+    }, callback)
+  }
+
+  // 数据清理 - 保留，实际在使用
+  cleanup() {
+    this.dataPool.manager.clearModelData(this.instanceId)
+    return this
+  }
+
+  // 获取数据池引用 - 保留，实际在使用
+  getDataPool() {
+    return this.dataPool
+  }
+}
+
+class TreeTableModelMethods extends BaseModelMethods {
+  constructor(instanceId, dataPool) {
+    super(instanceId, dataPool)
+    // 初始化 TreeTable 特有的数据结构 - 只保留必要的字段
+    this._initTreeTableData()
+  }
+
+  _initTreeTableData() {
+    // 设置初始元数据
+    this.setData('__meta__', {
+      type: 'tree-table',
+      instanceId: this.instanceId,
+      createdAt: Date.now()
+    })
+
+    // 使用 schema 初始化数据字段
+    const defaults = getFieldDefaults(TREE_TABLE_FIELDS)
+    for (const [fieldName, defaultValue] of Object.entries(defaults)) {
+      this.setData(fieldName, defaultValue)
+    }
+  }
+
+  // TreeTable 核心方法 - 只保留实际使用的
+  setCurrentRowData(data) {
+    this.setData('currentRowData', data)
+    return this
+  }
+
+  getCurrentRowData() {
+    return this.getData('currentRowData', {})
+  }
+
+  // 共享数据操作（与 modal table 交互）- 保留，实际在使用
+  setSharedData(data) {
+    if (data && Object.keys(data).length > 0) {
+      this.dataPool.manager.setSharedData('modalTable', 'parentCurrentRowData', data)
+    }
+    return this
+  }
+
+  getSharedData() {
+    return this.dataPool.manager.getSharedData('modalTable', 'parentCurrentRowData')
+  }
+
+  // 订阅共享数据变化 - 保留，实际在使用
+  subscribeShared(callback) {
+    return this.dataPool.manager.subscribe({
+      namespace: 'modalTable',
+      key: 'parentCurrentRowData'
+    }, callback)
+  }
+}
+
+class GlobalDataManager {
+  constructor() {
+    this.models = new Map()
+    this.runtimeContext = createDataPool()
+  }
+
+  // 注册模型实例 - 保留，实际在使用
+  registerModel(modelType, instanceId, methods) {
+    if (this.models.has(instanceId)) {
+      console.warn(`Model instance ${instanceId} already exists`)
+      return this
+    }
+
+    this.models.set(instanceId, {
+      type: modelType,
+      instanceId,
+      methods,
+      createdAt: Date.now()
+    })
+
+    return this
+  }
+
+  // 注销模型实例 - 保留，实际在使用
+  unregisterModel(instanceId) {
+    if (this.models.has(instanceId)) {
+      this.clearModelData(instanceId)
+      this.models.delete(instanceId)
+    }
+    return this
+  }
+
+  // 获取模型实例 - 保留，实际在使用
+  getModel(instanceId) {
+    const model = this.models.get(instanceId)
+    return model ? model.methods : null
+  }
+
+  // 获取指定类型的所有模型 - 保留，dataPoolAPI 中使用
+  getAllModels(modelType = null) {
+    const result = {}
+    for (const [instanceId, model] of this.models) {
+      if (!modelType || model.type === modelType) {
+        result[instanceId] = model.methods
+      }
+    }
+    return result
+  }
+
+  // 设置模型数据 - 保留，实际在使用
+  setData(instanceId, key, value) {
+    const model = this.models.get(instanceId)
+    if (!model) {
+      console.error(`Model instance ${instanceId} not found`)
+      return this
+    }
+
+    this.runtimeContext.set(instanceId, key, value)
+    return this
+  }
+
+  // 获取模型数据 - 保留，实际在使用
+  getData(instanceId, key, defaultValue = null) {
+    const model = this.models.get(instanceId)
+    if (!model) {
+      return defaultValue
+    }
+
+    return this.runtimeContext.get(instanceId, key, defaultValue)
+  }
+
+  // 设置共享数据 - 保留，实际在使用（modal table 交互）
+  setSharedData(namespace, key, value) {
+    const prefixedNamespace = `shared.${namespace}`
+    this.runtimeContext.set(prefixedNamespace, key, value)
+    return this
+  }
+
+  // 获取共享数据 - 保留，实际在使用
+  getSharedData(namespace, key, defaultValue = null) {
+    const prefixedNamespace = `shared.${namespace}`
+    return this.runtimeContext.get(prefixedNamespace, key, defaultValue)
+  }
+
+  // 订阅系统 - 保留，实际在使用
+  subscribe(filter, callback) {
+    return this.runtimeContext.subscribe(filter, callback)
+  }
+
+  // 清理模型数据 - 保留，实际在使用
+  clearModelData(instanceId) {
+    const model = this.models.get(instanceId)
+    if (model) {
+      this.runtimeContext.clear(instanceId)
+    }
+    return this
+  }
+}
+
+// 模型工厂 - 简化版，只支持 tree-table
+class ModelFactory {
+  static createModel(modelType, instanceId, options = {}) {
+    if (modelType !== 'tree-table') {
+      throw new Error(`Unsupported model type: ${modelType}. Only 'tree-table' is supported.`)
+    }
+
+    // 注册到全局数据池
+    window.__idooel_data_pool__.manager.registerModel(
+      modelType,
+      instanceId,
+      null // 占位符
+    )
+
+    // 创建 TreeTable 模型实例
+    const methods = new TreeTableModelMethods(instanceId, window.__idooel_data_pool__)
+
+    // 更新注册的方法引用
+    const model = window.__idooel_data_pool__.manager.models.get(instanceId)
+    if (model) {
+      model.methods = methods
+    }
+
+    return methods
+  }
+}
+
+// 初始化全局数据池 - 简化版
+function initGlobalDataPool() {
+  if (window.__idooel_data_pool__) {
+    return window.__idooel_data_pool__
+  }
+
+  const dataPool = {
+    // 全局管理接口
+    manager: new GlobalDataManager(),
+    
+    // 模型工厂
+    factory: ModelFactory,
+    
+    // 工具方法 - 只保留实际使用的
+    utils: {
+      // 生成唯一 ID - dataPoolAPI 中使用
+      generateId: (prefix = 'model') => `${prefix}_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`,
+      
+      // 获取时间戳 - dataPoolAPI 中使用
+      now: () => Date.now(),
+      
+      // 深拷贝 - dataPoolAPI 中使用
+      deepClone: (obj) => JSON.parse(JSON.stringify(obj)),
+      
+      // 类型检查 - dataPoolAPI 中使用
+      isObject: (val) => val !== null && typeof val === 'object',
+      isEmpty: (val) => {
+        if (val == null) return true
+        if (Array.isArray(val) || typeof val === 'string') return val.length === 0
+        if (typeof val === 'object') return Object.keys(val).length === 0
+        return false
+      }
+    }
+  }
+
+  // 挂载到 window
+  window.__idooel_data_pool__ = dataPool
+
+  return dataPool
+}
+
+// 初始化
+const globalDataPool = initGlobalDataPool()
+
+// 导出函数和实例
+export { BaseModelMethods, TreeTableModelMethods, GlobalDataManager, ModelFactory, initGlobalDataPool }
+export default globalDataPool

package/packages/utils/runtime-context/index.js

@@ -0,0 +1,76 @@
+/**
+ * Runtime Context 数据池模块
+ * 统一导出所有 runtime-context 相关的功能
+ */
+
+// 核心架构 - 确保全局数据池初始化
+import globalDataPoolInstance, { initGlobalDataPool, BaseModelMethods, TreeTableModelMethods, GlobalDataManager, ModelFactory } from './globalDataPool.js'
+// 确保全局数据池在使用前已初始化（全局数据池在模块加载时已经初始化）
+export { initGlobalDataPool, BaseModelMethods, TreeTableModelMethods, GlobalDataManager, ModelFactory }
+
+// API 接口
+import createDataPoolAPIDefault, { dataPoolAPI } from './dataPoolAPI.js'
+export { createDataPoolAPIDefault as createDataPoolAPI, dataPoolAPI }
+export {
+  createTreeTableModel,
+  getModel,
+  getAllModels,
+  destroyModel,
+  setModelData,
+  getModelData,
+  setBatchModelData,
+  getAllModelData,
+  setUserInfo,
+  getUserInfo,
+  setUserPermissions,
+  setSystemConfig,
+  getSystemConfig,
+  setSystemTheme,
+  getSystemTheme,
+  setModalParentData,
+  getModalParentData,
+  setBusinessDictionaries,
+  getBusinessDictionaries,
+  subscribeModelData,
+  subscribeUserInfo,
+  subscribeSystemConfig,
+  subscribeSystemTheme,
+  subscribeModalParentData,
+  exportModelData,
+  importModelData,
+  clearModelData,
+  getDebugInfo,
+  generateId,
+  deepClone,
+  isEmpty,
+  isObject,
+  now
+} from './dataPoolAPI.js'
+
+// 模型字段定义
+export {
+  FIELD_TYPES,
+  TREE_TABLE_FIELDS,
+  SHARED_FIELDS,
+  META_FIELDS,
+  getFieldDefaults,
+  validateFieldType,
+  getFieldDefinition,
+  getAllFields,
+  getSupportedFields
+} from './modelSchema.js'
+
+// 便捷的工厂函数
+export const createGlobalDataPool = () => {
+  if (!window.__idooel_data_pool__) {
+    throw new Error('Global data pool not initialized. Please import runtime-context/globalDataPool.js first.')
+  }
+  return window.__idooel_data_pool__
+}
+
+// 默认导出主要功能
+export default {
+  initGlobalDataPool,
+  createDataPoolAPI: createDataPoolAPIDefault,
+  createGlobalDataPool
+}

package/packages/utils/runtime-context/modelSchema.js

@@ -0,0 +1,174 @@
+/**
+ * 模型字段定义
+ * 定义 TreeTable 模型支持的数据字段和类型
+ */
+
+/**
+ * 字段类型定义
+ */
+export const FIELD_TYPES = {
+  OBJECT: 'object',
+  ARRAY: 'array',
+  STRING: 'string',
+  NUMBER: 'number',
+  BOOLEAN: 'boolean'
+}
+
+/**
+ * TreeTable 模型字段定义
+ */
+export const TREE_TABLE_FIELDS = {
+  // 当前选中的行数据 - 核心字段
+  currentRowData: {
+    type: FIELD_TYPES.OBJECT,
+    default: {},
+    description: '当前表格选中的行数据'
+  }
+}
+
+/**
+ * 共享数据字段定义
+ */
+export const SHARED_FIELDS = {
+  // Modal Table 父级数据
+  parentCurrentRowData: {
+    type: FIELD_TYPES.OBJECT,
+    default: null,
+    description: 'Modal Table 的父级表格当前行数据'
+  }
+}
+
+/**
+ * 模型元数据字段
+ */
+export const META_FIELDS = {
+  // 基础元数据
+  type: {
+    type: FIELD_TYPES.STRING,
+    default: 'tree-table',
+    description: '模型类型'
+  },
+  instanceId: {
+    type: FIELD_TYPES.STRING,
+    required: true,
+    description: '模型实例ID'
+  },
+  createdAt: {
+    type: FIELD_TYPES.NUMBER,
+    required: true,
+    description: '创建时间戳'
+  }
+}
+
+/**
+ * 获取字段默认值
+ * @param {object} schema 字段schema
+ * @returns {object} 默认值对象
+ */
+export const getFieldDefaults = (schema) => {
+  const defaults = {}
+  
+  for (const [fieldName, fieldConfig] of Object.entries(schema)) {
+    if (fieldConfig.default !== undefined) {
+      defaults[fieldName] = fieldConfig.default
+    } else if (fieldConfig.required) {
+      // 必填字段但没有默认值的处理
+      switch (fieldConfig.type) {
+        case FIELD_TYPES.OBJECT:
+          defaults[fieldName] = {}
+          break
+        case FIELD_TYPES.ARRAY:
+          defaults[fieldName] = []
+          break
+        case FIELD_TYPES.STRING:
+          defaults[fieldName] = ''
+          break
+        case FIELD_TYPES.NUMBER:
+          defaults[fieldName] = 0
+          break
+        case FIELD_TYPES.BOOLEAN:
+          defaults[fieldName] = false
+          break
+      }
+    }
+  }
+  
+  return defaults
+}
+
+/**
+ * 验证字段值是否符合类型要求
+ * @param {*} value 要验证的值
+ * @param {string} expectedType 期望的类型
+ * @returns {boolean} 是否有效
+ */
+export const validateFieldType = (value, expectedType) => {
+  if (value === null || value === undefined) {
+    return true // 允许空值
+  }
+  
+  const actualType = Array.isArray(value) ? FIELD_TYPES.ARRAY : typeof value
+  
+  // 宽松的类型检查
+  switch (expectedType) {
+    case FIELD_TYPES.OBJECT:
+      return actualType === FIELD_TYPES.OBJECT
+    case FIELD_TYPES.ARRAY:
+      return actualType === FIELD_TYPES.ARRAY
+    case FIELD_TYPES.STRING:
+      return actualType === FIELD_TYPES.STRING
+    case FIELD_TYPES.NUMBER:
+      return actualType === FIELD_TYPES.NUMBER
+    case FIELD_TYPES.BOOLEAN:
+      return actualType === FIELD_TYPES.BOOLEAN
+    default:
+      return true
+  }
+}
+
+/**
+ * 获取字段定义信息
+ * @param {string} fieldName 字段名
+ * @returns {object|null} 字段定义
+ */
+export const getFieldDefinition = (fieldName) => {
+  // 优先在 TreeTable 字段中查找
+  if (TREE_TABLE_FIELDS[fieldName]) {
+    return TREE_TABLE_FIELDS[fieldName]
+  }
+  
+  // 然后在共享字段中查找
+  if (SHARED_FIELDS[fieldName]) {
+    return SHARED_FIELDS[fieldName]
+  }
+  
+  // 最后在元数据字段中查找
+  if (META_FIELDS[fieldName]) {
+    return META_FIELDS[fieldName]
+  }
+  
+  return null
+}
+
+/**
+ * 获取所有字段定义
+ * @returns {object} 所有字段定义
+ */
+export const getAllFields = () => {
+  return {
+    ...TREE_TABLE_FIELDS,
+    ...SHARED_FIELDS,
+    ...META_FIELDS
+  }
+}
+
+/**
+ * 获取模型支持的字段列表
+ * @returns {string[]} 字段名列表
+ */
+export const getSupportedFields = () => {
+  return Object.keys({
+    ...TREE_TABLE_FIELDS,
+    ...SHARED_FIELDS
+  })
+}

package/scripts/rollup.config.js

@@ -1,43 +1,43 @@
-
-import { nodeResolve } from '@rollup/plugin-node-resolve'
-import { terser } from 'rollup-plugin-terser'
-import strip from '@rollup/plugin-strip'
-import vue from 'rollup-plugin-vue'
-import postcss from 'rollup-plugin-postcss'
-import postcssImport from 'postcss-import'
-import { babel } from '@rollup/plugin-babel'
-import alias from '@rollup/plugin-alias'
-import { resolve } from 'path'
-
-//TODO: bundle all packages in future
-
-/** @type { import('rollup').RollupOptions } */
-export default {
-  input: 'packages/index.js',
-  external: ['vue', '@idooel/shared', 'vue-upload-component', 'moment'],
-  plugins: [
-    nodeResolve(),
-    vue({
-      css: true,
-      compileTemplate: true
-    }),
-    alias({
-      entries: [
-        { find: '@/utils', replacement: resolve(__dirname, '../packages/utils') }
-      ]
-    }),
-    babel({
-      babelHelpers: 'bundled',
-      presets: ['@vue/babel-preset-jsx'],
-      extensions: ['.js', '.jsx', '.es', '.es6', '.mjs', '.vue'],
-      filter: id=>{
-        return /(\.js|\.jsx|\.es6|\.es|\.mjs)$/.test(id) && !/node_modules/.test(id)
-      }
-    }),
-    postcss({
-      extensions: ['.css', '.scss'],
-      extract: true,
-      plugins: [postcssImport()]
-    })
-  ]
+
+import { nodeResolve } from '@rollup/plugin-node-resolve'
+import { terser } from 'rollup-plugin-terser'
+import strip from '@rollup/plugin-strip'
+import vue from 'rollup-plugin-vue'
+import postcss from 'rollup-plugin-postcss'
+import postcssImport from 'postcss-import'
+import { babel } from '@rollup/plugin-babel'
+import alias from '@rollup/plugin-alias'
+import { resolve } from 'path'
+
+//TODO: bundle all packages in future
+
+/** @type { import('rollup').RollupOptions } */
+export default {
+  input: 'packages/index.js',
+  external: ['vue', '@idooel/runtime-context', '@idooel/shared', '@idooel/expression', 'vue-upload-component', 'moment'],
+  plugins: [
+    nodeResolve(),
+    vue({
+      css: true,
+      compileTemplate: true
+    }),
+    alias({
+      entries: [
+        { find: '@/utils', replacement: resolve(__dirname, '../packages/utils') }
+      ]
+    }),
+    babel({
+      babelHelpers: 'bundled',
+      presets: ['@vue/babel-preset-jsx'],
+      extensions: ['.js', '.jsx', '.es', '.es6', '.mjs', '.vue'],
+      filter: id=>{
+        return /(\.js|\.jsx|\.es6|\.es|\.mjs)$/.test(id) && !/node_modules/.test(id)
+      }
+    }),
+    postcss({
+      extensions: ['.css', '.scss'],
+      extract: true,
+      plugins: [postcssImport()]
+    })
+  ]
 }

package/scripts/rollup.esm.config.js

@@ -1,12 +1,12 @@
-import baseConfig from './rollup.config.js'
-import { module } from '../package.json'
-
-/** @type { import('rollup').RollupOptions } */
-export default {
-  ...baseConfig,
-  output: {
-    name: '__ele__esm__components__',
-    file: module,
-    format: 'es'
-  }
+import baseConfig from './rollup.config.js'
+import { module } from '../package.json'
+
+/** @type { import('rollup').RollupOptions } */
+export default {
+  ...baseConfig,
+  output: {
+    name: '__ele__esm__components__',
+    file: module,
+    format: 'es'
+  }
 }

package/scripts/rollup.umd.config.js

@@ -1,15 +1,18 @@
-import baseConfig from './rollup.config.js'
-import { main } from '../package.json'
-/** @type { import('rollup').RollupOptions } */
-export default {
-  ...baseConfig,
-  output: {
-    name: '__ele__umd__components__',
-    file: main,
-    format: 'umd',
-    globals: {
-      vue: 'Vue'
-    },
-    exports: 'named'
-  }
+import baseConfig from './rollup.config.js'
+import { main } from '../package.json'
+/** @type { import('rollup').RollupOptions } */
+export default {
+  ...baseConfig,
+  output: {
+    name: '__ele__umd__components__',
+    file: main,
+    format: 'umd',
+    globals: {
+      vue: 'Vue',
+      '@idooel/runtime-context': '@idooel/runtime-context',
+      '@idooel/shared': '@idooel/shared',
+      '@idooel/expression': '@idooel/expression'
+    },
+    exports: 'named'
+  }
 }

package/vitest.config.js

@@ -0,0 +1,17 @@
+import { defineConfig } from 'vitest/config'
+import vue from '@vitejs/plugin-vue2'
+import path from 'path'
+
+export default defineConfig({
+  plugins: [vue()],
+  resolve: {
+    alias: {
+      '@': path.resolve(__dirname, 'packages')
+    }
+  },
+  test: {
+    environment: 'jsdom',
+    globals: true,
+    setupFiles: ['__tests__/setup.js']
+  }
+})