zl-q
463 lines
14 KiB
Dart
463 lines
14 KiB
Dart
import 'package:flutter/material.dart';
|
|
import 'package:go_router/go_router.dart';
|
|
|
|
import 'package:social_app/core/theme/design_tokens.dart';
|
|
import 'package:social_app/shared/widgets/toast/toast.dart';
|
|
import 'package:social_app/shared/widgets/toast/toast_type.dart';
|
|
import '../navigation/ui_schema_navigation.dart';
|
|
|
|
class UiSchemaRenderer {
|
|
static Widget renderSchema(Map<String, dynamic>? schema) {
|
|
if (schema == null || schema.isEmpty) {
|
|
return const SizedBox.shrink();
|
|
}
|
|
final root = _asMap(schema['root']);
|
|
if (root == null) {
|
|
return _fallback('无效 UI Schema');
|
|
}
|
|
return _renderLayoutNode(root);
|
|
}
|
|
|
|
static Widget _renderLayoutNode(Map<String, dynamic> node) {
|
|
final type = _asString(node['type']);
|
|
return switch (type) {
|
|
'stack' => _renderStack(node),
|
|
'grid' => _renderGrid(node),
|
|
_ => _fallback('不支持的布局节点: $type'),
|
|
};
|
|
}
|
|
|
|
static Widget _renderNode(Map<String, dynamic> node) {
|
|
final type = _asString(node['type']);
|
|
if (node['visible'] == false) {
|
|
return const SizedBox.shrink();
|
|
}
|
|
return switch (type) {
|
|
'text' => _renderText(node),
|
|
'icon' => _renderIcon(node),
|
|
'badge' => _renderBadge(node),
|
|
'button' => _renderButton(node),
|
|
'kv' => _renderKv(node),
|
|
'divider' => _renderDivider(node),
|
|
'stack' => _renderStack(node),
|
|
'grid' => _renderGrid(node),
|
|
_ => _fallback('未知节点: $type'),
|
|
};
|
|
}
|
|
|
|
static Widget _renderStack(Map<String, dynamic> node) {
|
|
final children = _asList(
|
|
node['children'],
|
|
).whereType<Map<String, dynamic>>().map(_renderNode).toList();
|
|
final gap = _asDouble(node['gap'], fallback: AppSpacing.sm);
|
|
final direction = _asString(node['direction'], fallback: 'vertical');
|
|
|
|
Widget content;
|
|
if (direction == 'horizontal') {
|
|
content = Wrap(
|
|
direction: Axis.horizontal,
|
|
spacing: gap,
|
|
runSpacing: gap,
|
|
crossAxisAlignment: WrapCrossAlignment.center,
|
|
children: children,
|
|
);
|
|
} else {
|
|
content = Column(
|
|
crossAxisAlignment: CrossAxisAlignment.start,
|
|
children: _withGap(children, gap),
|
|
);
|
|
}
|
|
return _wrapSurface(node, content);
|
|
}
|
|
|
|
static Widget _renderGrid(Map<String, dynamic> node) {
|
|
final children = _asList(
|
|
node['children'],
|
|
).whereType<Map<String, dynamic>>().map(_renderNode).toList();
|
|
final columns = _asInt(node['columns'], fallback: 2).clamp(1, 3);
|
|
final gap = _asDouble(node['gap'], fallback: AppSpacing.sm);
|
|
return _wrapSurface(
|
|
node,
|
|
GridView.count(
|
|
crossAxisCount: columns,
|
|
crossAxisSpacing: gap,
|
|
mainAxisSpacing: gap,
|
|
childAspectRatio: 1.6,
|
|
physics: const NeverScrollableScrollPhysics(),
|
|
shrinkWrap: true,
|
|
children: children,
|
|
),
|
|
);
|
|
}
|
|
|
|
static Widget _renderText(Map<String, dynamic> node) {
|
|
final role = _asString(node['role'], fallback: 'body');
|
|
final status = _asString(node['status']);
|
|
final style = switch (role) {
|
|
'title' => const TextStyle(
|
|
fontSize: 18,
|
|
fontWeight: FontWeight.w700,
|
|
color: AppColors.slate900,
|
|
height: 1.2,
|
|
),
|
|
'subtitle' => const TextStyle(
|
|
fontSize: 14,
|
|
fontWeight: FontWeight.w600,
|
|
color: AppColors.slate800,
|
|
),
|
|
'caption' => const TextStyle(
|
|
fontSize: 11,
|
|
color: AppColors.slate500,
|
|
height: 1.4,
|
|
),
|
|
'code' => const TextStyle(
|
|
fontSize: 12,
|
|
color: AppColors.slate700,
|
|
fontFamily: 'monospace',
|
|
),
|
|
_ => const TextStyle(
|
|
fontSize: 13,
|
|
color: AppColors.slate700,
|
|
height: 1.35,
|
|
),
|
|
};
|
|
return Text(
|
|
_asString(node['content']),
|
|
maxLines: _asIntOrNull(node['maxLines']),
|
|
overflow: TextOverflow.ellipsis,
|
|
style: style.copyWith(color: _statusTextColor(status, style.color)),
|
|
);
|
|
}
|
|
|
|
static Widget _renderIcon(Map<String, dynamic> node) {
|
|
final value = _asString(node['value']);
|
|
if (_asString(node['source']) == 'emoji' && value.isNotEmpty) {
|
|
return Text(value, style: const TextStyle(fontSize: 18));
|
|
}
|
|
return Icon(Icons.bubble_chart_rounded, color: _statusTextColor('', null));
|
|
}
|
|
|
|
static Widget _renderBadge(Map<String, dynamic> node) {
|
|
final status = _asString(node['status']);
|
|
final fg =
|
|
_statusTextColor(status, AppColors.slate700) ?? AppColors.slate700;
|
|
final bg = _statusBackground(status);
|
|
return Container(
|
|
padding: const EdgeInsets.symmetric(
|
|
horizontal: AppSpacing.md,
|
|
vertical: AppSpacing.xs,
|
|
),
|
|
decoration: BoxDecoration(
|
|
color: bg,
|
|
borderRadius: BorderRadius.circular(AppRadius.full),
|
|
border: Border.all(color: _statusBorder(status)),
|
|
),
|
|
child: Text(
|
|
_asString(node['label']),
|
|
style: TextStyle(fontSize: 12, fontWeight: FontWeight.w700, color: fg),
|
|
),
|
|
);
|
|
}
|
|
|
|
static Widget _renderButton(Map<String, dynamic> node) {
|
|
final style = _asString(node['style'], fallback: 'secondary');
|
|
final action = _asMap(node['action']);
|
|
final disabled = node['disabled'] == true;
|
|
return Builder(
|
|
builder: (context) {
|
|
return ElevatedButton(
|
|
onPressed: disabled
|
|
? null
|
|
: () {
|
|
_handleAction(context, action);
|
|
},
|
|
style: ElevatedButton.styleFrom(
|
|
elevation: 0,
|
|
padding: const EdgeInsets.symmetric(
|
|
horizontal: AppSpacing.lg,
|
|
vertical: AppSpacing.sm,
|
|
),
|
|
backgroundColor: style == 'primary'
|
|
? AppColors.authPrimaryButton
|
|
: AppColors.surfaceInfoLight,
|
|
foregroundColor: style == 'primary'
|
|
? AppColors.white
|
|
: AppColors.slate700,
|
|
shape: RoundedRectangleBorder(
|
|
borderRadius: BorderRadius.circular(AppRadius.full),
|
|
side: style == 'primary'
|
|
? BorderSide.none
|
|
: const BorderSide(color: AppColors.borderTertiary),
|
|
),
|
|
),
|
|
child: Text(
|
|
_asString(node['label'], fallback: '操作'),
|
|
style: const TextStyle(fontSize: 12, fontWeight: FontWeight.w600),
|
|
),
|
|
);
|
|
},
|
|
);
|
|
}
|
|
|
|
static void _handleAction(
|
|
BuildContext context,
|
|
Map<String, dynamic>? action,
|
|
) {
|
|
final actionType = _asString(action?['type']);
|
|
switch (actionType) {
|
|
case 'copy':
|
|
Toast.show(context, '已复制', type: ToastType.success);
|
|
return;
|
|
case 'navigation':
|
|
_handleNavigationAction(context, action);
|
|
return;
|
|
default:
|
|
Toast.show(context, '该操作暂未接入', type: ToastType.info);
|
|
return;
|
|
}
|
|
}
|
|
|
|
static void _handleNavigationAction(
|
|
BuildContext context,
|
|
Map<String, dynamic>? action,
|
|
) {
|
|
if (action == null) {
|
|
Toast.show(context, '导航参数无效', type: ToastType.warning);
|
|
return;
|
|
}
|
|
|
|
final path = _asString(action['path']).trim();
|
|
if (!isValidInternalNavigationPath(path)) {
|
|
Toast.show(context, '导航路径无效', type: ToastType.warning);
|
|
return;
|
|
}
|
|
|
|
final params = _asMap(action['params']);
|
|
final shouldReplace = action['replace'] == true;
|
|
try {
|
|
final target = buildUiSchemaNavigationTarget(path: path, params: params);
|
|
if (shouldReplace) {
|
|
context.replace(target);
|
|
return;
|
|
}
|
|
context.push(target);
|
|
} on FormatException {
|
|
Toast.show(context, '导航路径无效', type: ToastType.warning);
|
|
}
|
|
}
|
|
|
|
static Widget _renderKv(Map<String, dynamic> node) {
|
|
final items = _asList(
|
|
node['items'],
|
|
).whereType<Map<String, dynamic>>().toList();
|
|
if (items.isEmpty) {
|
|
return const SizedBox.shrink();
|
|
}
|
|
return Column(
|
|
crossAxisAlignment: CrossAxisAlignment.start,
|
|
children: _withGap(
|
|
items.map((item) {
|
|
final label = _asString(
|
|
item['label'],
|
|
fallback: _asString(item['key']),
|
|
);
|
|
final value = item['value']?.toString() ?? '-';
|
|
return Container(
|
|
width: double.infinity,
|
|
padding: const EdgeInsets.symmetric(
|
|
horizontal: AppSpacing.md,
|
|
vertical: AppSpacing.xs,
|
|
),
|
|
decoration: BoxDecoration(
|
|
color: AppColors.surfaceSecondary,
|
|
borderRadius: BorderRadius.circular(AppRadius.md),
|
|
),
|
|
child: Row(
|
|
crossAxisAlignment: CrossAxisAlignment.start,
|
|
children: [
|
|
Expanded(
|
|
flex: 3,
|
|
child: Text(
|
|
label,
|
|
style: const TextStyle(
|
|
fontSize: 11,
|
|
color: AppColors.slate500,
|
|
),
|
|
),
|
|
),
|
|
const SizedBox(width: AppSpacing.sm),
|
|
Expanded(
|
|
flex: 5,
|
|
child: Text(
|
|
value,
|
|
style: const TextStyle(
|
|
fontSize: 12,
|
|
color: AppColors.slate800,
|
|
fontWeight: FontWeight.w600,
|
|
),
|
|
),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
}).toList(),
|
|
AppSpacing.xs,
|
|
),
|
|
);
|
|
}
|
|
|
|
static Widget _renderDivider(Map<String, dynamic> node) {
|
|
final inset = _asDouble(node['inset'], fallback: 0);
|
|
return Padding(
|
|
padding: EdgeInsets.symmetric(horizontal: inset),
|
|
child: const Divider(height: 1, color: AppColors.slate200),
|
|
);
|
|
}
|
|
|
|
static Widget _wrapSurface(Map<String, dynamic> node, Widget child) {
|
|
final appearance = _asString(node['appearance'], fallback: 'plain');
|
|
final status = _asString(node['status']);
|
|
if (appearance == 'plain') {
|
|
return child;
|
|
}
|
|
final bg = switch (appearance) {
|
|
'section' => AppColors.surfaceSecondary,
|
|
'card' => AppColors.white,
|
|
_ => _statusBackground(status),
|
|
};
|
|
final borderColor = switch (status) {
|
|
'success' => AppColors.feedbackSuccessBorder,
|
|
'warning' => AppColors.feedbackWarningBorder,
|
|
'error' => AppColors.feedbackErrorBorder,
|
|
_ => AppColors.homeConversationBorder,
|
|
};
|
|
return Container(
|
|
width: double.infinity,
|
|
padding: const EdgeInsets.all(AppSpacing.md),
|
|
decoration: BoxDecoration(
|
|
color: bg,
|
|
borderRadius: BorderRadius.circular(AppRadius.lg),
|
|
border: Border.all(color: borderColor),
|
|
boxShadow: [
|
|
BoxShadow(
|
|
color: AppColors.slate200.withValues(alpha: 0.35),
|
|
blurRadius: 12,
|
|
offset: const Offset(0, 6),
|
|
),
|
|
],
|
|
),
|
|
child: child,
|
|
);
|
|
}
|
|
|
|
static Widget _fallback(String text) {
|
|
return Container(
|
|
padding: const EdgeInsets.all(AppSpacing.md),
|
|
decoration: BoxDecoration(
|
|
color: AppColors.feedbackWarningSurface,
|
|
border: Border.all(color: AppColors.feedbackWarningBorder),
|
|
borderRadius: BorderRadius.circular(AppRadius.md),
|
|
),
|
|
child: Text(
|
|
text,
|
|
style: const TextStyle(
|
|
fontSize: 12,
|
|
color: AppColors.feedbackWarningText,
|
|
),
|
|
),
|
|
);
|
|
}
|
|
|
|
static List<Widget> _withGap(List<Widget> widgets, double gap) {
|
|
if (widgets.isEmpty) return const [];
|
|
return [
|
|
widgets.first,
|
|
for (int i = 1; i < widgets.length; i++) ...[
|
|
SizedBox(height: gap),
|
|
widgets[i],
|
|
],
|
|
];
|
|
}
|
|
|
|
static Color _statusBackground(String status) {
|
|
return switch (status) {
|
|
'success' => AppColors.feedbackSuccessSurface,
|
|
'warning' => AppColors.feedbackWarningSurface,
|
|
'error' => AppColors.feedbackErrorSurface,
|
|
'pending' => AppColors.feedbackInfoSurface,
|
|
_ => AppColors.surfaceSecondary,
|
|
};
|
|
}
|
|
|
|
static Color _statusBorder(String status) {
|
|
return switch (status) {
|
|
'success' => AppColors.feedbackSuccessBorder,
|
|
'warning' => AppColors.feedbackWarningBorder,
|
|
'error' => AppColors.feedbackErrorBorder,
|
|
'pending' => AppColors.feedbackInfoBorder,
|
|
_ => AppColors.borderTertiary,
|
|
};
|
|
}
|
|
|
|
static Color? _statusTextColor(String status, Color? fallback) {
|
|
return switch (status) {
|
|
'success' => AppColors.feedbackSuccessText,
|
|
'warning' => AppColors.feedbackWarningText,
|
|
'error' => AppColors.feedbackErrorText,
|
|
'pending' => AppColors.feedbackInfoText,
|
|
_ => fallback,
|
|
};
|
|
}
|
|
|
|
static Map<String, dynamic>? _asMap(Object? value) {
|
|
if (value is Map<String, dynamic>) {
|
|
return value;
|
|
}
|
|
if (value is Map) {
|
|
return Map<String, dynamic>.from(value);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
static List<dynamic> _asList(Object? value) {
|
|
return value is List ? value : const [];
|
|
}
|
|
|
|
static String _asString(Object? value, {String fallback = ''}) {
|
|
return value is String ? value : fallback;
|
|
}
|
|
|
|
static int _asInt(Object? value, {int fallback = 0}) {
|
|
if (value is int) {
|
|
return value;
|
|
}
|
|
if (value is double) {
|
|
return value.toInt();
|
|
}
|
|
if (value is String) {
|
|
return int.tryParse(value) ?? fallback;
|
|
}
|
|
return fallback;
|
|
}
|
|
|
|
static int? _asIntOrNull(Object? value) {
|
|
if (value == null) {
|
|
return null;
|
|
}
|
|
return _asInt(value);
|
|
}
|
|
|
|
static double _asDouble(Object? value, {double fallback = 0}) {
|
|
if (value is double) {
|
|
return value;
|
|
}
|
|
if (value is int) {
|
|
return value.toDouble();
|
|
}
|
|
if (value is String) {
|
|
return double.tryParse(value) ?? fallback;
|
|
}
|
|
return fallback;
|
|
}
|
|
}
|