zl-q
413 lines
12 KiB
Dart
413 lines
12 KiB
Dart
import 'package:flutter/material.dart';
|
|
|
|
import 'package:social_app/core/l10n/l10n.dart';
|
|
import 'package:social_app/core/theme/design_tokens.dart';
|
|
|
|
class UiSchemaRenderer {
|
|
final ColorScheme colorScheme;
|
|
|
|
UiSchemaRenderer(this.colorScheme);
|
|
|
|
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(L10n.current.uiSchemaInvalid);
|
|
}
|
|
return _renderLayoutNode(root);
|
|
}
|
|
|
|
Widget _renderLayoutNode(Map<String, dynamic> node) {
|
|
final type = _asString(node['type']);
|
|
return switch (type) {
|
|
'stack' => _renderStack(node),
|
|
'grid' => _renderGrid(node),
|
|
_ => _fallback(L10n.current.uiSchemaUnsupportedLayout(type)),
|
|
};
|
|
}
|
|
|
|
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(L10n.current.uiSchemaUnknownNode(type)),
|
|
};
|
|
}
|
|
|
|
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);
|
|
}
|
|
|
|
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,
|
|
),
|
|
);
|
|
}
|
|
|
|
Widget _renderText(Map<String, dynamic> node) {
|
|
final role = _asString(node['role'], fallback: 'body');
|
|
final status = _asString(node['status']);
|
|
final style = switch (role) {
|
|
'title' => TextStyle(
|
|
fontSize: 18,
|
|
fontWeight: FontWeight.w700,
|
|
color: colorScheme.onSurface,
|
|
height: 1.2,
|
|
),
|
|
'subtitle' => TextStyle(
|
|
fontSize: 14,
|
|
fontWeight: FontWeight.w600,
|
|
color: colorScheme.onSurface,
|
|
),
|
|
'caption' => TextStyle(
|
|
fontSize: 11,
|
|
color: colorScheme.onSurfaceVariant,
|
|
height: 1.4,
|
|
),
|
|
'code' => TextStyle(
|
|
fontSize: 12,
|
|
color: colorScheme.onSurfaceVariant,
|
|
fontFamily: 'monospace',
|
|
),
|
|
_ => TextStyle(
|
|
fontSize: 13,
|
|
color: colorScheme.onSurfaceVariant,
|
|
height: 1.35,
|
|
),
|
|
};
|
|
return Text(
|
|
_asString(node['content']),
|
|
maxLines: _asIntOrNull(node['maxLines']),
|
|
overflow: TextOverflow.ellipsis,
|
|
style: style.copyWith(color: _statusTextColor(status, style.color)),
|
|
);
|
|
}
|
|
|
|
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));
|
|
}
|
|
|
|
Widget _renderBadge(Map<String, dynamic> node) {
|
|
final status = _asString(node['status']);
|
|
final fg =
|
|
_statusTextColor(status, colorScheme.onSurfaceVariant) ??
|
|
colorScheme.onSurfaceVariant;
|
|
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),
|
|
),
|
|
);
|
|
}
|
|
|
|
Widget _renderButton(Map<String, dynamic> node) {
|
|
final style = _asString(node['style'], fallback: 'secondary');
|
|
final action = _asMap(node['action']);
|
|
final disabled = node['disabled'] == true;
|
|
return ElevatedButton(
|
|
onPressed: disabled
|
|
? null
|
|
: () {
|
|
_handleAction(action);
|
|
},
|
|
style: ElevatedButton.styleFrom(
|
|
elevation: 0,
|
|
padding: const EdgeInsets.symmetric(
|
|
horizontal: AppSpacing.lg,
|
|
vertical: AppSpacing.sm,
|
|
),
|
|
backgroundColor: style == 'primary'
|
|
? colorScheme.primary
|
|
: colorScheme.surfaceContainerHighest,
|
|
foregroundColor: style == 'primary'
|
|
? colorScheme.onPrimary
|
|
: colorScheme.onSurfaceVariant,
|
|
shape: RoundedRectangleBorder(
|
|
borderRadius: BorderRadius.circular(AppRadius.full),
|
|
side: style == 'primary'
|
|
? BorderSide.none
|
|
: BorderSide(color: colorScheme.outlineVariant),
|
|
),
|
|
),
|
|
child: Text(
|
|
_asString(node['label'], fallback: L10n.current.uiSchemaActionFallback),
|
|
style: const TextStyle(fontSize: 12, fontWeight: FontWeight.w600),
|
|
),
|
|
);
|
|
}
|
|
|
|
void _handleAction(Map<String, dynamic>? action) {}
|
|
|
|
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: colorScheme.surfaceContainerHighest,
|
|
borderRadius: BorderRadius.circular(AppRadius.md),
|
|
),
|
|
child: Row(
|
|
crossAxisAlignment: CrossAxisAlignment.start,
|
|
children: [
|
|
Expanded(
|
|
flex: 3,
|
|
child: Text(
|
|
label,
|
|
style: TextStyle(
|
|
fontSize: 11,
|
|
color: colorScheme.onSurfaceVariant,
|
|
),
|
|
),
|
|
),
|
|
const SizedBox(width: AppSpacing.sm),
|
|
Expanded(
|
|
flex: 5,
|
|
child: Text(
|
|
value,
|
|
style: TextStyle(
|
|
fontSize: 12,
|
|
color: colorScheme.onSurface,
|
|
fontWeight: FontWeight.w600,
|
|
),
|
|
),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
}).toList(),
|
|
AppSpacing.xs,
|
|
),
|
|
);
|
|
}
|
|
|
|
Widget _renderDivider(Map<String, dynamic> node) {
|
|
final inset = _asDouble(node['inset'], fallback: 0);
|
|
return Padding(
|
|
padding: EdgeInsets.symmetric(horizontal: inset),
|
|
child: Divider(height: 1, color: colorScheme.outlineVariant),
|
|
);
|
|
}
|
|
|
|
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' => colorScheme.surfaceContainerHighest,
|
|
'card' => colorScheme.surface,
|
|
_ => _statusBackground(status),
|
|
};
|
|
final borderColor = switch (status) {
|
|
'success' => colorScheme.tertiary,
|
|
'warning' => colorScheme.secondary,
|
|
'error' => colorScheme.error,
|
|
_ => colorScheme.outlineVariant,
|
|
};
|
|
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: colorScheme.shadow.withValues(alpha: 0.08),
|
|
blurRadius: 12,
|
|
offset: const Offset(0, 6),
|
|
),
|
|
],
|
|
),
|
|
child: child,
|
|
);
|
|
}
|
|
|
|
Widget _fallback(String text) {
|
|
return Container(
|
|
padding: const EdgeInsets.all(AppSpacing.md),
|
|
decoration: BoxDecoration(
|
|
color: colorScheme.secondaryContainer,
|
|
border: Border.all(color: colorScheme.secondary),
|
|
borderRadius: BorderRadius.circular(AppRadius.md),
|
|
),
|
|
child: Text(
|
|
text,
|
|
style: TextStyle(fontSize: 12, color: colorScheme.onSecondaryContainer),
|
|
),
|
|
);
|
|
}
|
|
|
|
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],
|
|
],
|
|
];
|
|
}
|
|
|
|
Color _statusBackground(String status) {
|
|
return switch (status) {
|
|
'success' => colorScheme.tertiaryContainer,
|
|
'warning' => colorScheme.secondaryContainer,
|
|
'error' => colorScheme.errorContainer,
|
|
'pending' => colorScheme.primaryContainer,
|
|
_ => colorScheme.surfaceContainerHighest,
|
|
};
|
|
}
|
|
|
|
Color _statusBorder(String status) {
|
|
return switch (status) {
|
|
'success' => colorScheme.tertiary,
|
|
'warning' => colorScheme.secondary,
|
|
'error' => colorScheme.error,
|
|
'pending' => colorScheme.primary,
|
|
_ => colorScheme.outlineVariant,
|
|
};
|
|
}
|
|
|
|
Color? _statusTextColor(String status, Color? fallback) {
|
|
return switch (status) {
|
|
'success' => colorScheme.onTertiaryContainer,
|
|
'warning' => colorScheme.onSecondaryContainer,
|
|
'error' => colorScheme.onErrorContainer,
|
|
'pending' => colorScheme.onPrimaryContainer,
|
|
_ => 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;
|
|
}
|
|
}
|