scaffold-engine 0.1.0

package/tools/lib/model-toolkit.cjs

@@ -0,0 +1,482 @@
+const fs = require('fs');
+const path = require('path');
+
+function requireOptionalDependency(name) {
+  try {
+    return require(name);
+  } catch (error) {
+    throw new Error(`缺少依赖 "${name}"。请先在仓库中执行 pnpm install 后再运行 scaffold 工具链。`);
+  }
+}
+
+const YAML = requireOptionalDependency('yaml');
+const Ajv = requireOptionalDependency('ajv');
+const { SCAFFOLD_ROOT, loadRuntimeConfig, resolveRulePath } = require('./runtime-config.cjs');
+
+function resolveScaffoldPath(...segments) {
+  return path.join(SCAFFOLD_ROOT, ...segments);
+}
+
+function readText(filePath) {
+  return fs.readFileSync(filePath, 'utf8');
+}
+
+function readJson(filePath) {
+  return JSON.parse(readText(filePath));
+}
+
+function loadSpec(filePath) {
+  const absolutePath = path.resolve(filePath);
+  const content = readText(absolutePath);
+  const ext = path.extname(absolutePath).toLowerCase();
+
+  if (ext === '.yaml' || ext === '.yml') {
+    return { absolutePath, model: YAML.parse(content) };
+  }
+
+  if (ext === '.json') {
+    return { absolutePath, model: JSON.parse(content) };
+  }
+
+  throw new Error(`不支持的模型文件格式: ${absolutePath}`);
+}
+
+function validateSchema(model, schemaPath) {
+  const schema = readJson(schemaPath);
+  delete schema.$schema;
+  const ajv = new Ajv({ allErrors: true, strict: false });
+  const validate = ajv.compile(schema);
+  const valid = validate(model);
+  return {
+    valid,
+    errors: valid
+      ? []
+      : (validate.errors || []).map((item) => {
+          const pathText = item.instancePath || '/';
+          return `[schema] ${pathText} ${item.message || 'invalid'}`;
+        }),
+  };
+}
+
+function validateBusinessRules(model, boundaries) {
+  const errors = [];
+  const warnings = [];
+
+  const systemFields = new Set(boundaries.systemFields || []);
+  const reservedTables = new Set(boundaries.reservedTables || []);
+  const reservedPrefixes = boundaries.reservedTablePrefixes || [];
+  const protectedDomains = new Set((boundaries.protectedDomains || []).map((item) => String(item).toLowerCase()));
+  const protectedObjects = new Set((boundaries.protectedMetaObjects || []).map((item) => String(item).toLowerCase()));
+
+  const meta = model.meta || {};
+  const data = model.data || {};
+  const app = model.app || {};
+  const ui = model.ui || {};
+  const fields = Array.isArray(data.fields) ? data.fields : [];
+  const children = Array.isArray(data.children) ? data.children : [];
+
+  if (protectedDomains.has(String(meta.domain || '').toLowerCase())) {
+    errors.push(`[boundary] meta.domain=${meta.domain} 属于受保护域，不能作为业务扩展对象`);
+  }
+
+  if (protectedObjects.has(String(meta.object || '').toLowerCase())) {
+    errors.push(`[boundary] meta.object=${meta.object} 属于受保护对象，不能作为业务扩展对象`);
+  }
+
+  validateTableName(data.table, 'data.table', reservedTables, reservedPrefixes, errors);
+  for (const child of children) {
+    validateTableName(child.table, `data.children.${child.name}.table`, reservedTables, reservedPrefixes, errors);
+  }
+
+  validateUniqueNames(fields.map((item) => item.name), 'data.fields', errors);
+  validateUniqueNames(children.map((item) => item.name), 'data.children', errors);
+
+  for (const child of children) {
+    validateUniqueNames((child.fields || []).map((item) => item.name), `data.children.${child.name}.fields`, errors);
+  }
+
+  const rootFieldNames = new Set(fields.map((item) => item.name));
+  const childNames = new Set(children.map((item) => item.name));
+  const allowedRootRefs = new Set([...rootFieldNames, ...systemFields]);
+
+  const listColumns = (ui.list && Array.isArray(ui.list.columns)) ? ui.list.columns : [];
+  const listFilters = (ui.list && Array.isArray(ui.list.filters)) ? ui.list.filters : [];
+  const formGroups = (ui.form && Array.isArray(ui.form.groups)) ? ui.form.groups : [];
+
+  for (const item of listColumns) {
+    if (!allowedRootRefs.has(item)) {
+      errors.push(`[ui] list.columns 引用了不存在的字段: ${item}`);
+    }
+  }
+
+  for (const item of listFilters) {
+    if (!allowedRootRefs.has(item)) {
+      errors.push(`[ui] list.filters 引用了不存在的字段: ${item}`);
+    }
+  }
+
+  for (const group of formGroups) {
+    if (Array.isArray(group.fields)) {
+      for (const fieldName of group.fields) {
+        if (!rootFieldNames.has(fieldName)) {
+          errors.push(`[ui] form.groups(${group.title}) 引用了不存在的字段: ${fieldName}`);
+        }
+      }
+    }
+    if (group.childTable && !childNames.has(group.childTable)) {
+      errors.push(`[ui] form.groups(${group.title}) 引用了不存在的子表: ${group.childTable}`);
+    }
+  }
+
+  const actions = Array.isArray(app.actions) ? app.actions : [];
+  const statusFlow = app.statusFlow || null;
+  const responseContract = app.responseContract || null;
+  const permissionProfile = app.permissionProfile || null;
+  const validationRules = Array.isArray(app.validationRules) ? app.validationRules : [];
+  const errorCodes = Array.isArray(app.errorCodes) ? app.errorCodes : [];
+  if ((actions.includes('activate') || actions.includes('deactivate')) && !rootFieldNames.has('status')) {
+    errors.push('[app] 启用/停用动作依赖 status 字段，但当前模型未定义 status');
+  }
+  if (statusFlow) {
+    if (!rootFieldNames.has('status')) {
+      errors.push('[app] statusFlow 依赖 status 字段，但当前模型未定义 status');
+    }
+    const states = new Set(Array.isArray(statusFlow.states) ? statusFlow.states : []);
+    if (states.size === 0) {
+      errors.push('[app] statusFlow.states 不能为空');
+    }
+    if (app.defaultStatus && !states.has(app.defaultStatus)) {
+      errors.push(`[app] defaultStatus=${app.defaultStatus} 未在 statusFlow.states 中定义`);
+    }
+    for (const transition of Array.isArray(statusFlow.transitions) ? statusFlow.transitions : []) {
+      if (!actions.includes(transition.action)) {
+        errors.push(`[app] statusFlow.transitions.action=${transition.action} 未在 app.actions 中声明`);
+      }
+      for (const fromState of transition.from || []) {
+        if (!states.has(fromState)) {
+          errors.push(`[app] statusFlow.transitions.from 包含未定义状态: ${fromState}`);
+        }
+      }
+      if (transition.to && !states.has(transition.to)) {
+        errors.push(`[app] statusFlow.transitions.to=${transition.to} 未在 statusFlow.states 中定义`);
+      }
+    }
+  }
+  if (errorCodes.length > 0) {
+    validateUniqueNames(errorCodes.map((item) => item.code), 'app.errorCodes', errors);
+  }
+  if (responseContract) {
+    if (actions.includes('list') && !responseContract.listSchema) {
+      errors.push('[app] list 动作要求声明 responseContract.listSchema');
+    }
+    if (actions.includes('detail') && !responseContract.detailSchema) {
+      errors.push('[app] detail 动作要求声明 responseContract.detailSchema');
+    }
+  }
+  if (permissionProfile) {
+    for (const item of permissionProfile.actionPolicies || []) {
+      if (!actions.includes(item.action)) {
+        errors.push(`[app] permissionProfile.actionPolicies.action=${item.action} 未在 app.actions 中声明`);
+      }
+    }
+  }
+  if (validationRules.length > 0) {
+    validateUniqueNames(validationRules.map((item) => item.name), 'app.validationRules', errors);
+    for (const rule of validationRules) {
+      for (const fieldName of rule.fields || []) {
+        if (!rootFieldNames.has(fieldName) && !systemFields.has(fieldName)) {
+          errors.push(`[app] validationRules(${rule.name}) 引用了不存在的字段: ${fieldName}`);
+        }
+      }
+    }
+  }
+
+  for (const field of fields) {
+    if (field.type === 'enum' && (!Array.isArray(field.options) || field.options.length === 0)) {
+      errors.push(`[data] 枚举字段 ${field.name} 缺少 options`);
+    }
+  }
+
+  for (const child of children) {
+    for (const field of child.fields || []) {
+      if (field.type === 'enum' && (!Array.isArray(field.options) || field.options.length === 0)) {
+        errors.push(`[data] 子表 ${child.name} 中的枚举字段 ${field.name} 缺少 options`);
+      }
+    }
+    if (!child.foreignKey) {
+      errors.push(`[data] 子表 ${child.name} 缺少 foreignKey`);
+    }
+  }
+
+  if (fields.length < 3) {
+    warnings.push('[data] 当前主表字段较少，作为业务试点对象可能过于简单');
+  }
+  if (!responseContract) {
+    warnings.push('[app] 当前模型未声明 responseContract，后续接 IDE 入口时建议补齐接口返回约定');
+  }
+  if (!permissionProfile) {
+    warnings.push('[app] 当前模型未声明 permissionProfile，后续接 IDE 入口时建议补齐权限占位');
+  }
+
+  return { errors, warnings };
+}
+
+function validateTableName(tableName, label, reservedTables, reservedPrefixes, errors) {
+  if (!tableName) {
+    errors.push(`[boundary] ${label} 不能为空`);
+    return;
+  }
+
+  if (reservedTables.has(tableName)) {
+    errors.push(`[boundary] ${label}=${tableName} 属于系统保留表`);
+    return;
+  }
+
+  for (const prefix of reservedPrefixes) {
+    if (tableName.startsWith(prefix)) {
+      errors.push(`[boundary] ${label}=${tableName} 使用了系统保留前缀 ${prefix}`);
+    }
+  }
+}
+
+function validateUniqueNames(names, label, errors) {
+  const seen = new Set();
+  for (const name of names) {
+    if (seen.has(name)) {
+      errors.push(`[data] ${label} 存在重复名称: ${name}`);
+      continue;
+    }
+    seen.add(name);
+  }
+}
+
+function validateModelFile(specPath, runtimeConfigOrOptions = {}) {
+  const runtimeConfig = runtimeConfigOrOptions?.rules
+    ? runtimeConfigOrOptions
+    : loadRuntimeConfig(runtimeConfigOrOptions);
+  const schemaPath = resolveRulePath(runtimeConfig, 'businessModelSchema');
+  const boundariesPath = resolveRulePath(runtimeConfig, 'extensionBoundaries');
+  const governancePath = resolveRulePath(runtimeConfig, 'specGovernance');
+  const { absolutePath, model } = loadSpec(specPath);
+  const schemaResult = validateSchema(model, schemaPath);
+  const boundaryResult = validateBusinessRules(model, readJson(boundariesPath));
+  const locationResult = validateSpecLocation(absolutePath, model, readJson(governancePath), runtimeConfig);
+  return {
+    absolutePath,
+    model,
+    schemaErrors: schemaResult.errors,
+    boundaryErrors: boundaryResult.errors,
+    governanceErrors: locationResult.errors,
+    warnings: [...boundaryResult.warnings, ...locationResult.warnings],
+    location: locationResult.location,
+    valid: schemaResult.errors.length === 0
+      && boundaryResult.errors.length === 0
+      && locationResult.errors.length === 0,
+  };
+}
+
+function validateSpecLocation(absolutePath, model, governance, runtimeConfig) {
+  const location = classifySpecLocation(absolutePath, governance, runtimeConfig);
+  const errors = [];
+  const warnings = [];
+  const meta = model.meta || {};
+  const domain = String(meta.domain || '');
+  const object = String(meta.object || '');
+  const description = String(meta.description || '').trim();
+
+  if (location.scope === 'unknown') {
+    warnings.push('[governance] 当前模型文件不在受管 spec 目录下，后续不建议作为模板或项目资产沉淀');
+    return { location, errors, warnings };
+  }
+
+  if (!location.policy.allowCustomDomain && domain === 'custom') {
+    errors.push(`[governance] ${location.scope} 范围不允许使用 custom domain`);
+  }
+
+  if (location.policy.requireDescription && !description) {
+    warnings.push(`[governance] ${location.scope} 范围建议补充 meta.description，便于后续模板治理`);
+  }
+
+  if (location.policy.forbidSampleObjectSuffix && /sample$/i.test(object)) {
+    errors.push(`[governance] ${location.scope} 范围不应保留 *Sample 这类临时对象名`);
+  }
+
+  if (location.policy.requirePattern && !meta.pattern) {
+    errors.push(`[governance] ${location.scope} 范围必须声明 meta.pattern`);
+  }
+
+  return { location, errors, warnings };
+}
+
+function classifySpecLocation(absolutePath, governance, runtimeConfig) {
+  const root = runtimeConfig?.scaffoldRoot || SCAFFOLD_ROOT;
+  const relativePath = path.relative(root, absolutePath).replace(/\\/g, '/');
+  const scopes = governance.scopes || {};
+  const orderedScopes = Object.entries(scopes).sort((a, b) => {
+    const aLen = Math.max(...(a[1].roots || ['']).map((item) => item.length));
+    const bLen = Math.max(...(b[1].roots || ['']).map((item) => item.length));
+    return bLen - aLen;
+  });
+
+  for (const [scope, policy] of orderedScopes) {
+    const roots = Array.isArray(policy.roots) ? policy.roots : [];
+    if (roots.some((root) => relativePath.startsWith(root))) {
+      return { scope, relativePath, policy };
+    }
+  }
+
+  return { scope: 'unknown', relativePath, policy: {} };
+}
+
+function splitWords(value) {
+  return String(value)
+    .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+    .replace(/[^a-zA-Z0-9]+/g, ' ')
+    .trim()
+    .split(/\s+/)
+    .filter(Boolean);
+}
+
+function pascalCase(value) {
+  return splitWords(value)
+    .map((part) => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase())
+    .join('');
+}
+
+function camelCase(value) {
+  const text = pascalCase(value);
+  return text ? text.charAt(0).toLowerCase() + text.slice(1) : text;
+}
+
+function kebabCase(value) {
+  return splitWords(value).map((part) => part.toLowerCase()).join('-');
+}
+
+function snakeCase(value) {
+  return splitWords(value).map((part) => part.toLowerCase()).join('_');
+}
+
+function ensureDir(dirPath) {
+  fs.mkdirSync(dirPath, { recursive: true });
+}
+
+function writeGeneratedFile(filePath, content, options) {
+  const { force = false, dryRun = false } = options || {};
+  if (fs.existsSync(filePath) && !force) {
+    return { status: 'skipped', filePath };
+  }
+
+  if (!dryRun) {
+    ensureDir(path.dirname(filePath));
+    fs.writeFileSync(filePath, content, 'utf8');
+  }
+
+  return { status: dryRun ? 'planned' : 'written', filePath };
+}
+
+function buildContext(model) {
+  const meta = model.meta;
+  const data = model.data;
+  const ui = model.ui;
+  const app = model.app;
+  const objectPascal = pascalCase(meta.object);
+  const objectCamel = camelCase(meta.object);
+  const objectKebab = kebabCase(meta.object);
+  const domainKebab = kebabCase(meta.domain);
+  const domainUpper = String(meta.domain).toUpperCase();
+  const moduleSlug = `${domainKebab}-${objectKebab}`;
+  const routePath = `${domainKebab}-${objectKebab}`;
+  const apiBasePath = `/${domainKebab}/${objectKebab}`;
+  const pattern = meta.pattern || '';
+
+  const rootFields = normalizeFields(data.fields || []);
+  const childTables = (data.children || []).map((item) => ({
+    ...item,
+    className: `${objectPascal}${pascalCase(item.name)}`,
+    variableName: camelCase(item.name),
+    fileName: `${objectKebab}-${kebabCase(item.name)}`,
+    fields: normalizeFields(item.fields || []),
+  }));
+
+  return {
+    meta,
+    data,
+    app,
+    ui,
+    moduleSlug,
+    routePath,
+    apiBasePath,
+    objectPascal,
+    objectCamel,
+    objectKebab,
+    domainKebab,
+    domainUpper,
+    pattern,
+    label: meta.label,
+    fields: rootFields,
+    childTables,
+    hasAction(action) {
+      return Array.isArray(app.actions) && app.actions.includes(action);
+    },
+  };
+}
+
+function normalizeFields(fields) {
+  return fields.map((field) => ({
+    ...field,
+    column: field.column || snakeCase(field.name),
+    tsType: mapToTsType(field.type),
+    sqlType: mapToSqlType(field.type),
+  }));
+}
+
+function mapToTsType(type) {
+  switch (type) {
+    case 'boolean':
+      return 'boolean';
+    case 'integer':
+    case 'number':
+    case 'decimal':
+      return 'number';
+    case 'date':
+    case 'datetime':
+      return 'Date';
+    default:
+      return 'string';
+  }
+}
+
+function mapToSqlType(type) {
+  switch (type) {
+    case 'text':
+      return 'text';
+    case 'boolean':
+      return 'integer';
+    case 'integer':
+      return 'integer';
+    case 'number':
+    case 'decimal':
+      return 'decimal(18,2)';
+    case 'date':
+    case 'datetime':
+      return 'datetime';
+    default:
+      return 'varchar(255)';
+  }
+}
+
+module.exports = {
+  SCAFFOLD_ROOT,
+  buildContext,
+  camelCase,
+  ensureDir,
+  kebabCase,
+  loadRuntimeConfig,
+  loadSpec,
+  pascalCase,
+  readJson,
+  resolveScaffoldPath,
+  snakeCase,
+  validateModelFile,
+  writeGeneratedFile,
+};

package/tools/lib/pattern-renderers.cjs

@@ -0,0 +1,166 @@
+const PATTERN_CONFIG = {
+  singleEntity: {
+    icon: 'Package',
+    listSubtitle: '标准单实体页面，适合台账、档案、基础资料类对象。',
+    formSubtitle: (context) => `补齐${context.label}基础字段`,
+    detailSubtitle: (context) => `${context.label}基础信息详情`,
+    listTitle: (context) => `${context.label}台账`,
+    createLabel: (context) => `新建${context.label}`,
+    searchPlaceholder: (context, fieldLabel) => `搜索${fieldLabel}或编码...`,
+    fieldPriority: {
+      code: ['materialCode', 'warehouseCode', 'supplierCode', 'productCode', 'employeeCode', 'customerCode'],
+      title: ['materialName', 'warehouseName', 'supplierName', 'productName', 'employeeName', 'customerName'],
+      search: ['materialName', 'materialCode', 'customerName', 'customerCode'],
+      secondary: ['materialType', 'materialGroup', 'baseUnit', 'status'],
+      header: ['materialCode', 'materialType', 'materialGroup', 'baseUnit', 'status'],
+    },
+  },
+  masterDetail: {
+    icon: 'Building2',
+    listSubtitle: '标准主子表页面，适合主表带一张子表的对象。',
+    formSubtitle: (context) => `补齐${context.label}主数据与子表信息`,
+    detailSubtitle: (context) => `${context.label}主数据与联系人详情`,
+    listTitle: (context) => `${context.label}管理`,
+    createLabel: (context) => `新建${context.label}`,
+    searchPlaceholder: (context, fieldLabel) => `搜索${fieldLabel}或联系人相关信息...`,
+    fieldPriority: {
+      code: ['customerCode', 'supplierCode', 'partnerCode'],
+      title: ['customerName', 'supplierName', 'partnerName'],
+      search: ['customerName', 'customerCode', 'supplierName', 'supplierCode'],
+      secondary: ['ownerName', 'source', 'status'],
+      header: ['customerCode', 'ownerName', 'source', 'status'],
+    },
+  },
+  statusEntity: {
+    icon: (context) => (context.objectKebab.includes('lead') ? 'Target' : 'BriefcaseBusiness'),
+    listSubtitle: '标准状态对象页面，聚焦阶段、状态与负责人协同。',
+    formSubtitle: (context) => `补齐${context.label}过程字段与状态信息`,
+    detailSubtitle: (context) => `${context.label}过程对象详情`,
+    listTitle: (context) => `${context.label}管理`,
+    createLabel: (context) => `新建${context.label}`,
+    searchPlaceholder: (context, fieldLabel) => `搜索${fieldLabel}、阶段或客户...`,
+    fieldPriority: {
+      code: ['leadCode', 'opportunityCode', 'quoteCode', 'contractCode'],
+      title: ['leadName', 'opportunityName', 'quoteName', 'contractName'],
+      search: ['leadName', 'opportunityName', 'quoteName', 'leadCode', 'opportunityCode', 'quoteCode'],
+      secondary: ['ownerName', 'customerName', 'stage', 'source', 'status'],
+      header: ['leadCode', 'opportunityCode', 'quoteCode', 'customerName', 'ownerName', 'stage', 'status'],
+    },
+  },
+  documentLines: {
+    icon: 'FileSpreadsheet',
+    listSubtitle: '标准单据对象页面，适合头表加行项目明细的对象。',
+    formSubtitle: (context) => `补齐${context.label}头信息与明细行`,
+    detailSubtitle: (context) => `${context.label}单据与明细详情`,
+    listTitle: (context) => `${context.label}单据`,
+    createLabel: (context) => `新建${context.label}`,
+    searchPlaceholder: (context, fieldLabel) => `搜索${fieldLabel}、业务日期或状态...`,
+    fieldPriority: {
+      code: ['documentNo', 'orderNo', 'requestNo', 'billNo'],
+      title: ['documentTitle', 'orderTitle', 'requestTitle', 'billTitle'],
+      search: ['documentNo', 'documentTitle', 'orderNo', 'orderTitle'],
+      secondary: ['bizDate', 'status', 'ownerName'],
+      header: ['documentNo', 'bizDate', 'ownerName', 'status'],
+    },
+  },
+  treeEntity: {
+    icon: 'Folders',
+    listSubtitle: '标准树形对象页面，适合组织、类目、科目等层级结构。',
+    formSubtitle: (context) => `补齐${context.label}层级字段`,
+    detailSubtitle: (context) => `${context.label}层级详情`,
+    listTitle: (context) => `${context.label}树`,
+    createLabel: (context) => `新建${context.label}`,
+    searchPlaceholder: (context, fieldLabel) => `搜索${fieldLabel}或层级节点...`,
+    fieldPriority: {
+      code: ['categoryCode', 'deptCode', 'subjectCode', 'code'],
+      title: ['categoryName', 'deptName', 'subjectName', 'name'],
+      search: ['categoryName', 'deptName', 'subjectName', 'name', 'categoryCode', 'deptCode', 'subjectCode', 'code'],
+      secondary: ['parentName', 'status'],
+      header: ['code', 'parentName', 'status'],
+    },
+  },
+};
+
+function getPatternId(context) {
+  return String(context.pattern || '');
+}
+
+function getPatternConfig(context) {
+  return PATTERN_CONFIG[getPatternId(context)] || null;
+}
+
+function isPattern(context, pattern) {
+  return getPatternId(context) === pattern;
+}
+
+function resolvePatternValue(context, key, fallback) {
+  const config = getPatternConfig(context);
+  const value = config?.[key];
+  if (typeof value === 'function') {
+    return value(context);
+  }
+  return value || fallback;
+}
+
+function getAdminHeaderIcon(context) {
+  const icon = resolvePatternValue(context, 'icon', '');
+  if (icon) {
+    return icon;
+  }
+  if (context.objectKebab.includes('lead')) {
+    return 'Target';
+  }
+  if (context.objectKebab.includes('customer')) {
+    return 'Building2';
+  }
+  if (context.objectKebab.includes('opportunity')) {
+    return 'BriefcaseBusiness';
+  }
+  return 'Building2';
+}
+
+function getPatternListSubtitle(context) {
+  return resolvePatternValue(context, 'listSubtitle', '由业务模型生成的标准对象页面，已接入真实列表与基础操作。');
+}
+
+function getPatternFormSubtitle(context) {
+  return resolvePatternValue(context, 'formSubtitle', `补齐${context.label}主数据`);
+}
+
+function getPatternDetailSubtitle(context) {
+  return resolvePatternValue(context, 'detailSubtitle', `${context.label}主数据详情`);
+}
+
+function getPatternListTitle(context) {
+  return resolvePatternValue(context, 'listTitle', `${context.label}管理`);
+}
+
+function getPatternCreateLabel(context) {
+  return resolvePatternValue(context, 'createLabel', `新建${context.label}`);
+}
+
+function getPatternSearchPlaceholder(context, fieldLabel) {
+  const config = getPatternConfig(context);
+  const value = config?.searchPlaceholder;
+  if (typeof value === 'function') {
+    return value(context, fieldLabel);
+  }
+  return value || `搜索${fieldLabel}...`;
+}
+
+function getPatternFieldPriority(context, slot) {
+  return getPatternConfig(context)?.fieldPriority?.[slot] || [];
+}
+
+module.exports = {
+  getAdminHeaderIcon,
+  getPatternCreateLabel,
+  getPatternDetailSubtitle,
+  getPatternFieldPriority,
+  getPatternFormSubtitle,
+  getPatternId,
+  getPatternListSubtitle,
+  getPatternListTitle,
+  getPatternSearchPlaceholder,
+  isPattern,
+};