getlotui 0.1.0

package/dist/templates/flutter/Accordion.dart

@@ -0,0 +1,142 @@
+import 'package:flutter/material.dart';
+
+enum CrossUIAccordionType { single, multiple }
+
+class CrossUIAccordionItem {
+  final String value;
+  final String trigger;
+  final String content;
+
+  const CrossUIAccordionItem({
+    required this.value,
+    required this.trigger,
+    required this.content,
+  });
+}
+
+class CrossUIAccordion extends StatefulWidget {
+  final List<CrossUIAccordionItem> items;
+  final CrossUIAccordionType type;
+  final bool collapsible;
+  final dynamic defaultValue;
+
+  const CrossUIAccordion({
+    super.key,
+    required this.items,
+    this.type = CrossUIAccordionType.single,
+    this.collapsible = false,
+    this.defaultValue,
+  });
+
+  @override
+  State<CrossUIAccordion> createState() => _CrossUIAccordionState();
+}
+
+class _CrossUIAccordionState extends State<CrossUIAccordion> {
+  late Set<String> _openItems;
+
+  @override
+  void initState() {
+    super.initState();
+    _openItems = {};
+
+    if (widget.defaultValue != null) {
+      if (widget.defaultValue is String) {
+        _openItems.add(widget.defaultValue as String);
+      } else if (widget.defaultValue is List) {
+        _openItems.addAll((widget.defaultValue as List).cast<String>());
+      }
+    }
+  }
+
+  void _toggleItem(String value) {
+    setState(() {
+      if (widget.type == CrossUIAccordionType.single) {
+        if (_openItems.contains(value)) {
+          if (widget.collapsible) {
+            _openItems.clear();
+          }
+        } else {
+          _openItems.clear();
+          _openItems.add(value);
+        }
+      } else {
+        if (_openItems.contains(value)) {
+          _openItems.remove(value);
+        } else {
+          _openItems.add(value);
+        }
+      }
+    });
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return Column(
+      children: widget.items.asMap().entries.map((entry) {
+        final index = entry.key;
+        final item = entry.value;
+        final isOpen = _openItems.contains(item.value);
+        final isLast = index == widget.items.length - 1;
+
+        return Container(
+          decoration: BoxDecoration(
+            border: Border(
+              bottom: isLast
+                  ? BorderSide.none
+                  : const BorderSide(color: Colors.grey, width: 1),
+            ),
+          ),
+          child: Column(
+            crossAxisAlignment: CrossAxisAlignment.start,
+            children: [
+              InkWell(
+                onTap: () => _toggleItem(item.value),
+                child: Padding(
+                  padding: const EdgeInsets.symmetric(vertical: 16),
+                  child: Row(
+                    mainAxisAlignment: MainAxisAlignment.spaceBetween,
+                    children: [
+                      Expanded(
+                        child: Text(
+                          item.trigger,
+                          style: const TextStyle(
+                            fontSize: 16,
+                            fontWeight: FontWeight.w500,
+                          ),
+                        ),
+                      ),
+                      AnimatedRotation(
+                        turns: isOpen ? 0.75 : 0.25,
+                        duration: const Duration(milliseconds: 200),
+                        child: const Icon(Icons.chevron_right, size: 20),
+                      ),
+                    ],
+                  ),
+                ),
+              ),
+              AnimatedCrossFade(
+                firstChild: const SizedBox.shrink(),
+                secondChild: Padding(
+                  padding: const EdgeInsets.only(bottom: 16),
+                  child: Text(
+                    item.content,
+                    style: TextStyle(
+                      fontSize: 14,
+                      color: Colors.grey[600],
+                      height: 1.5,
+                    ),
+                  ),
+                ),
+                crossFadeState: isOpen
+                    ? CrossFadeState.showSecond
+                    : CrossFadeState.showFirst,
+                duration: const Duration(milliseconds: 200),
+              ),
+            ],
+          ),
+        );
+      }).toList(),
+    );
+  }
+}

package/dist/templates/flutter/Alert.dart

@@ -0,0 +1,96 @@
+import 'package:flutter/material.dart';
+import '../theme/tokens.dart';
+
+enum CrossUIAlertVariant { info, success, warning, destructive }
+
+class CrossUIAlert extends StatelessWidget {
+  final String title;
+  final String? description;
+  final CrossUIAlertVariant variant;
+  final IconData? icon;
+
+  const CrossUIAlert({
+    Key? key,
+    required this.title,
+    this.description,
+    this.variant = CrossUIAlertVariant.info,
+    this.icon,
+  }) : super(key: key);
+
+  @override
+  Widget build(BuildContext context) {
+    Color borderColor;
+    Color backgroundColor;
+    Color iconColor;
+    IconData defaultIcon;
+
+    switch (variant) {
+      case CrossUIAlertVariant.success:
+        borderColor = CrossUITokens.success;
+        backgroundColor = CrossUITokens.successLight;
+        iconColor = CrossUITokens.onSuccessLight;
+        defaultIcon = Icons.check_circle_outline;
+        break;
+      case CrossUIAlertVariant.warning:
+        borderColor = CrossUITokens.warning;
+        backgroundColor = CrossUITokens.warningLight;
+        iconColor = CrossUITokens.onWarningLight;
+        defaultIcon = Icons.warning_amber_rounded;
+        break;
+      case CrossUIAlertVariant.destructive:
+        borderColor = CrossUITokens.danger;
+        backgroundColor = CrossUITokens.dangerLight;
+        iconColor = CrossUITokens.onDangerLight;
+        defaultIcon = Icons.error_outline;
+        break;
+      case CrossUIAlertVariant.info:
+      default:
+        borderColor = CrossUITokens.info;
+        backgroundColor = CrossUITokens.infoLight;
+        iconColor = CrossUITokens.onInfoLight;
+        defaultIcon = Icons.info_outline;
+        break;
+    }
+
+    return Container(
+      padding: const EdgeInsets.all(CrossUITokens.spacingM),
+      decoration: BoxDecoration(
+        color: backgroundColor,
+        borderRadius: BorderRadius.circular(CrossUITokens.radiusMedium),
+        border: Border.all(color: borderColor.withOpacity(0.5)),
+      ),
+      child: Row(
+        crossAxisAlignment: CrossAxisAlignment.start,
+        children: [
+          Icon(icon ?? defaultIcon, color: iconColor, size: 20),
+          const SizedBox(width: CrossUITokens.spacingSm),
+          Expanded(
+            child: Column(
+              crossAxisAlignment: CrossAxisAlignment.start,
+              children: [
+                Text(
+                  title,
+                  style: TextStyle(
+                    fontWeight: FontWeight.bold,
+                    fontSize: CrossUITokens.fontSizeBase,
+                    color: iconColor,
+                  ),
+                ),
+                if (description != null) ...[
+                  const SizedBox(height: 4),
+                  Text(
+                    description!,
+                    style: TextStyle(
+                      fontSize: CrossUITokens.fontSizeSm,
+                      color: iconColor.withOpacity(0.8),
+                    ),
+                  ),
+                ],
+              ],
+            ),
+          ),
+        ],
+      ),
+    );
+  }
+}

package/dist/templates/flutter/AlertDialog.dart

@@ -0,0 +1,175 @@
+import 'package:flutter/material.dart';
+
+enum CrossUIAlertDialogVariant { defaultVariant, destructive }
+
+class CrossUIAlertDialog extends StatelessWidget {
+  final String title;
+  final String? description;
+  final String cancelText;
+  final String actionText;
+  final VoidCallback? onCancel;
+  final VoidCallback? onAction;
+  final CrossUIAlertDialogVariant variant;
+  final Widget? content;
+
+  const CrossUIAlertDialog({
+    super.key,
+    required this.title,
+    this.description,
+    this.cancelText = 'Cancel',
+    this.actionText = 'Continue',
+    this.onCancel,
+    this.onAction,
+    this.variant = CrossUIAlertDialogVariant.defaultVariant,
+    this.content,
+  });
+
+  static Future<T?> show<T>({
+    required BuildContext context,
+    required String title,
+    String? description,
+    String cancelText = 'Cancel',
+    String actionText = 'Continue',
+    VoidCallback? onCancel,
+    VoidCallback? onAction,
+    CrossUIAlertDialogVariant variant =
+        CrossUIAlertDialogVariant.defaultVariant,
+    Widget? content,
+  }) {
+    return showDialog<T>(
+      context: context,
+      barrierDismissible: true,
+      builder: (BuildContext context) {
+        return CrossUIAlertDialog(
+          title: title,
+          description: description,
+          cancelText: cancelText,
+          actionText: actionText,
+          onCancel: onCancel,
+          onAction: onAction,
+          variant: variant,
+          content: content,
+        );
+      },
+    );
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    Color actionBackgroundColor;
+    Color actionTextColor;
+
+    if (variant == CrossUIAlertDialogVariant.destructive) {
+      actionBackgroundColor = Colors.red;
+      actionTextColor = Colors.white;
+    } else {
+      actionBackgroundColor = Colors.blue;
+      actionTextColor = Colors.white;
+    }
+
+    return Dialog(
+      shape: RoundedRectangleBorder(
+        borderRadius: BorderRadius.circular(16),
+        side: BorderSide(color: Colors.grey.withValues(alpha: 0.2), width: 1),
+      ),
+      child: Container(
+        constraints: const BoxConstraints(maxWidth: 400),
+        padding: const EdgeInsets.all(24),
+        child: Column(
+          mainAxisSize: MainAxisSize.min,
+          crossAxisAlignment: CrossAxisAlignment.start,
+          children: [
+            Column(
+              crossAxisAlignment: CrossAxisAlignment.start,
+              children: [
+                Text(
+                  title,
+                  style: const TextStyle(
+                    fontSize: 18,
+                    fontWeight: FontWeight.w700,
+                  ),
+                ),
+                if (description != null) ...[
+                  const SizedBox(height: 8),
+                  Text(
+                    description!,
+                    style: TextStyle(
+                      fontSize: 14,
+                      color: Colors.grey[600],
+                      height: 1.5,
+                    ),
+                  ),
+                ],
+              ],
+            ),
+            if (content != null) ...[const SizedBox(height: 16), content!],
+            const SizedBox(height: 24),
+            Row(
+              mainAxisAlignment: MainAxisAlignment.end,
+              children: [
+                Expanded(
+                  child: InkWell(
+                    onTap: () {
+                      onCancel?.call();
+                      Navigator.of(context).pop(false);
+                    },
+                    borderRadius: BorderRadius.circular(8),
+                    child: Container(
+                      padding: const EdgeInsets.symmetric(
+                        horizontal: 16,
+                        vertical: 12,
+                      ),
+                      decoration: BoxDecoration(
+                        border: Border.all(
+                          color: Colors.grey.withValues(alpha: 0.3),
+                        ),
+                        borderRadius: BorderRadius.circular(8),
+                      ),
+                      child: const Text(
+                        'Cancel',
+                        textAlign: TextAlign.center,
+                        style: TextStyle(
+                          fontSize: 16,
+                          fontWeight: FontWeight.w600,
+                        ),
+                      ),
+                    ),
+                  ),
+                ),
+                const SizedBox(width: 8),
+                Expanded(
+                  child: InkWell(
+                    onTap: () {
+                      onAction?.call();
+                      Navigator.of(context).pop(true);
+                    },
+                    borderRadius: BorderRadius.circular(8),
+                    child: Container(
+                      padding: const EdgeInsets.symmetric(
+                        horizontal: 16,
+                        vertical: 12,
+                      ),
+                      decoration: BoxDecoration(
+                        color: actionBackgroundColor,
+                        borderRadius: BorderRadius.circular(8),
+                      ),
+                      child: Text(
+                        actionText,
+                        textAlign: TextAlign.center,
+                        style: TextStyle(
+                          fontSize: 16,
+                          fontWeight: FontWeight.w600,
+                          color: actionTextColor,
+                        ),
+                      ),
+                    ),
+                  ),
+                ),
+              ],
+            ),
+          ],
+        ),
+      ),
+    );
+  }
+}

package/dist/templates/flutter/Avatar.dart

@@ -0,0 +1,82 @@
+import 'package:flutter/material.dart';
+
+enum CrossUIAvatarSize { xs, sm, md, lg, xl, xxl }
+
+class CrossUIAvatar extends StatelessWidget {
+  final String? src;
+  final String? fallback;
+  final CrossUIAvatarSize size;
+
+  const CrossUIAvatar({
+    super.key,
+    this.src,
+    this.fallback,
+    this.size = CrossUIAvatarSize.md,
+  });
+
+  @override
+  Widget build(BuildContext context) {
+    double dimension;
+    double fontSize;
+
+    switch (size) {
+      case CrossUIAvatarSize.xs:
+        dimension = 24.0;
+        fontSize = 10.0;
+        break;
+      case CrossUIAvatarSize.sm:
+        dimension = 32.0;
+        fontSize = 12.0;
+        break;
+      case CrossUIAvatarSize.lg:
+        dimension = 48.0;
+        fontSize = 16.0;
+        break;
+      case CrossUIAvatarSize.xl:
+        dimension = 64.0;
+        fontSize = 20.0;
+        break;
+      case CrossUIAvatarSize.xxl:
+        dimension = 80.0;
+        fontSize = 24.0;
+        break;
+      case CrossUIAvatarSize.md:
+        dimension = 40.0;
+        fontSize = 14.0;
+        break;
+    }
+
+    return Container(
+      width: dimension,
+      height: dimension,
+      decoration: BoxDecoration(
+        color: Colors.blue.withValues(alpha: 0.1),
+        shape: BoxShape.circle,
+        border: Border.all(color: Colors.grey.withValues(alpha: 0.2), width: 1),
+      ),
+      clipBehavior: Clip.antiAlias,
+      child: src != null
+          ? Image.network(
+              src!,
+              fit: BoxFit.cover,
+              errorBuilder: (context, error, stackTrace) =>
+                  _buildFallback(fontSize),
+            )
+          : _buildFallback(fontSize),
+    );
+  }
+
+  Widget _buildFallback(double fontSize) {
+    return Center(
+      child: Text(
+        fallback?.substring(0, fallback!.length >= 2 ? 2 : 1).toUpperCase() ??
+            "??",
+        style: TextStyle(
+          color: Colors.blue,
+          fontSize: fontSize,
+          fontWeight: FontWeight.w600,
+        ),
+      ),
+    );
+  }
+}

package/dist/templates/flutter/Badge.dart

@@ -0,0 +1,89 @@
+import 'package:flutter/material.dart';
+
+enum CrossUIBadgeVariant {
+  defaultVariant,
+  secondary,
+  outline,
+  destructive,
+  success,
+  warning,
+}
+
+enum CrossUIBadgeSize { sm, md }
+
+class CrossUIBadge extends StatelessWidget {
+  final String label;
+  final CrossUIBadgeVariant variant;
+  final CrossUIBadgeSize size;
+
+  const CrossUIBadge({
+    super.key,
+    required this.label,
+    this.variant = CrossUIBadgeVariant.defaultVariant,
+    this.size = CrossUIBadgeSize.md,
+  });
+
+  @override
+  Widget build(BuildContext context) {
+    Color backgroundColor;
+    Color textColor;
+    BorderSide borderSide = BorderSide.none;
+
+    switch (variant) {
+      case CrossUIBadgeVariant.secondary:
+        backgroundColor = Colors.blue.withValues(alpha: 0.1);
+        textColor = Colors.blue;
+        break;
+      case CrossUIBadgeVariant.outline:
+        backgroundColor = Colors.transparent;
+        textColor = Colors.blue;
+        borderSide = const BorderSide(color: Colors.blue);
+        break;
+      case CrossUIBadgeVariant.destructive:
+        backgroundColor = Colors.red;
+        textColor = Colors.white;
+        break;
+      case CrossUIBadgeVariant.success:
+        backgroundColor = Colors.green.withValues(alpha: 0.1);
+        textColor = Colors.green;
+        break;
+      case CrossUIBadgeVariant.warning:
+        backgroundColor = Colors.amber.withValues(alpha: 0.1);
+        textColor = Colors.amber;
+        break;
+      case CrossUIBadgeVariant.defaultVariant:
+        backgroundColor = Colors.blue;
+        textColor = Colors.white;
+        break;
+    }
+
+    EdgeInsets padding;
+    double fontSize;
+
+    if (size == CrossUIBadgeSize.sm) {
+      padding = const EdgeInsets.symmetric(horizontal: 6, vertical: 2);
+      fontSize = 10;
+    } else {
+      padding = const EdgeInsets.symmetric(horizontal: 10, vertical: 4);
+      fontSize = 12;
+    }
+
+    return Container(
+      padding: padding,
+      decoration: BoxDecoration(
+        color: backgroundColor,
+        borderRadius: BorderRadius.circular(999),
+        border: Border.fromBorderSide(borderSide),
+      ),
+      child: Text(
+        label.toUpperCase(),
+        style: TextStyle(
+          color: textColor,
+          fontSize: fontSize,
+          fontWeight: FontWeight.w700,
+          letterSpacing: 0.5,
+        ),
+      ),
+    );
+  }
+}

package/dist/templates/flutter/Button.dart

@@ -0,0 +1,116 @@
+import 'package:flutter/material.dart';
+import '../theme/config.dart';
+
+enum CrossUIButtonVariant {
+  defaultVariant,
+  secondary,
+  outline,
+  ghost,
+  destructive,
+}
+
+enum CrossUIButtonSize { sm, defaultSize, lg }
+
+class CrossUIButton extends StatelessWidget {
+  final String label;
+  final VoidCallback? onPressed;
+  final CrossUIButtonVariant variant;
+  final CrossUIButtonSize size;
+  final bool disabled;
+  final Widget? icon;
+
+  const CrossUIButton({
+    Key? key,
+    required this.label,
+    this.onPressed,
+    this.variant = CrossUIButtonVariant.defaultVariant,
+    this.size = CrossUIButtonSize.defaultSize,
+    this.disabled = false,
+    this.icon,
+  }) : super(key: key);
+
+  @override
+  Widget build(BuildContext context) {
+    Color backgroundColor;
+    Color foregroundColor;
+    BorderSide borderSide = BorderSide.none;
+
+    final themeColors = CrossUITheme.colors;
+
+    switch (variant) {
+      case CrossUIButtonVariant.secondary:
+        backgroundColor = themeColors['secondary'] ?? Colors.grey;
+        foregroundColor = Colors.white;
+        break;
+      case CrossUIButtonVariant.outline:
+        backgroundColor = Colors.transparent;
+        foregroundColor = themeColors['primary'] ?? Colors.blue;
+        borderSide = BorderSide(color: themeColors['primary'] ?? Colors.blue);
+        break;
+      case CrossUIButtonVariant.ghost:
+        backgroundColor = Colors.transparent;
+        foregroundColor = themeColors['primary'] ?? Colors.blue;
+        break;
+      case CrossUIButtonVariant.destructive:
+        backgroundColor = Colors.red;
+        foregroundColor = Colors.white;
+        break;
+      case CrossUIButtonVariant.defaultVariant:
+      default:
+        backgroundColor = themeColors['primary'] ?? Colors.blue;
+        foregroundColor = themeColors['background'] ?? Colors.white;
+        break;
+    }
+
+    if (disabled) {
+      backgroundColor = backgroundColor.withOpacity(0.5);
+      foregroundColor = foregroundColor.withOpacity(0.5);
+    }
+
+    EdgeInsets padding;
+    double fontSize;
+    switch (size) {
+      case CrossUIButtonSize.sm:
+        padding = const EdgeInsets.symmetric(horizontal: 12, vertical: 8);
+        fontSize = CrossUITokens.fontSizeSm;
+        break;
+      case CrossUIButtonSize.lg:
+        padding = const EdgeInsets.symmetric(horizontal: 24, vertical: 16);
+        fontSize = CrossUITokens.fontSizeLg;
+        break;
+      case CrossUIButtonSize.defaultSize:
+      default:
+        padding = const EdgeInsets.symmetric(horizontal: 16, vertical: 12);
+        fontSize = CrossUITokens.fontSizeBase;
+        break;
+    }
+
+    return InkWell(
+      onTap: disabled ? null : onPressed,
+      borderRadius: BorderRadius.circular(CrossUITokens.radiusMedium),
+      child: Container(
+        padding: padding,
+        decoration: BoxDecoration(
+          color: backgroundColor,
+          borderRadius: BorderRadius.circular(CrossUITokens.radiusMedium),
+          border: Border.fromBorderSide(borderSide),
+        ),
+        child: Row(
+          mainAxisSize: MainAxisSize.min,
+          mainAxisAlignment: MainAxisAlignment.center,
+          children: [
+            if (icon != null) ...[icon!, const SizedBox(width: 8)],
+            Text(
+              label,
+              style: TextStyle(
+                color: foregroundColor,
+                fontSize: fontSize,
+                fontWeight: FontWeight.w600,
+              ),
+            ),
+          ],
+        ),
+      ),
+    );
+  }
+}