@momo-kits/native-kits 0.0.1-beta.5 → 0.0.2-alpha.1

package/ios/Typography/Text.swift

@@ -0,0 +1,262 @@
+import SwiftUI
+
+/// Non-reactive entry point, for call sites that cannot read the environment (UIKit bridges,
+/// free functions). Inside a SwiftUI view prefer `@Environment(\.momoFontScale)` so the view
+/// re-renders when Dynamic Type or the host preference changes.
+public func scaleSize(_ size: CGFloat) -> CGFloat {
+    FontScaleStore.shared.snapshot(size)
+}
+
+@available(*, deprecated, message: "Max font scale is fixed at 1.5; this override is no longer applied. Drop the second argument.")
+public func scaleSize(_ size: CGFloat, _ scaleRate: CGFloat?) -> CGFloat {
+    scaleSize(size)
+}
+
+public enum TypographyStyle {
+    case headlineDefaultBold
+    case headerMBold
+    case headerDefaultBold
+    case headerSSemibold
+    case headerXsSemibold
+    case bodyDefaultRegular
+    case bodyDefaultRegularStrikethrough
+    case descriptionDefaultRegular
+    case descriptionDefaultRegularStrikethrough
+    case descriptionXsRegular
+    case descriptionXsRegularStrikethrough
+    case labelDefaultMedium
+    case labelSMedium
+    case labelXsMedium
+    case actionDefaultBold
+    case actionSBold
+    case actionXsBold
+    case actionXxsBold
+}
+
+public extension TypographyStyle {
+    var fontSize: CGFloat {
+        switch self {
+        case .headlineDefaultBold: return 24
+        case .headerMBold: return 18
+        case .headerDefaultBold: return 16
+        case .headerSSemibold: return 14
+        case .headerXsSemibold: return 12
+        case .bodyDefaultRegular, .bodyDefaultRegularStrikethrough: return 14
+        case .descriptionDefaultRegular, .descriptionDefaultRegularStrikethrough: return 12
+        case .descriptionXsRegular, .descriptionXsRegularStrikethrough: return 10
+        case .labelDefaultMedium: return 14
+        case .labelSMedium: return 12
+        case .labelXsMedium: return 10
+        case .actionDefaultBold: return 16
+        case .actionSBold: return 14
+        case .actionXsBold: return 12
+        case .actionXxsBold: return 10
+        }
+    }
+    var lineHeight: CGFloat {
+        switch self {
+        case .headlineDefaultBold: return 34
+        case .headerMBold: return 26
+        case .headerDefaultBold: return 22
+        case .headerSSemibold: return 20
+        case .headerXsSemibold: return 18
+        case .bodyDefaultRegular, .bodyDefaultRegularStrikethrough: return 20
+        case .descriptionDefaultRegular, .descriptionDefaultRegularStrikethrough: return 18
+        case .descriptionXsRegular, .descriptionXsRegularStrikethrough: return 14
+        case .labelDefaultMedium: return 20
+        case .labelSMedium: return 18
+        case .labelXsMedium: return 14
+        case .actionDefaultBold: return 22
+        case .actionSBold: return 20
+        case .actionXsBold: return 18
+        case .actionXxsBold: return 14
+        }
+    }
+    var fontWeight: Font.Weight {
+        switch self {
+        case .headlineDefaultBold, .headerMBold, .headerDefaultBold,
+                .actionDefaultBold, .actionSBold, .actionXsBold, .actionXxsBold:
+            return .bold
+        case .headerSSemibold, .headerXsSemibold:
+            return .semibold
+        case .bodyDefaultRegular, .bodyDefaultRegularStrikethrough,
+                .descriptionDefaultRegular, .descriptionDefaultRegularStrikethrough,
+                .descriptionXsRegular, .descriptionXsRegularStrikethrough:
+            return .regular
+        case .labelDefaultMedium, .labelSMedium, .labelXsMedium:
+            return .medium
+        }
+    }
+    var isStrikethrough: Bool {
+        switch self {
+        case .bodyDefaultRegularStrikethrough,
+                .descriptionDefaultRegularStrikethrough,
+                .descriptionXsRegularStrikethrough:
+            return true
+        default:
+            return false
+        }
+    }
+}
+
+private func momoFontName(family: String, weight: Font.Weight) -> String? {
+    // Ngoai whitelist thi tra nil de momoFont() roi ve .system(...), dung nhu truoc DS-791.
+    guard KitDesignSystem.shared.isWhiteList else { return nil }
+    guard family == "MomoTrustSans" else { return nil }
+    switch weight {
+    case .ultraLight, .thin: return "MomoTrustSans-ExtraLight"
+    case .light: return "MomoTrustSans-Light"
+    case .regular: return "MomoTrustSans-Regular"
+    case .medium: return "MomoTrustSans-Medium"
+    case .semibold: return "MomoTrustSans-SemiBold"
+    case .bold: return "MomoTrustSans-Bold"
+    case .heavy, .black: return "MomoTrustSans-ExtraBold"
+    default: return "MomoTrustSans-Regular"
+    }
+}
+
+private func momoFont(size: CGFloat, weight: Font.Weight, family: String) -> Font {
+    guard let name = momoFontName(family: family, weight: weight),
+          UIFont(name: name, size: size) != nil else {
+        return .system(size: size, weight: weight)
+    }
+    return .custom(name, fixedSize: size)
+}
+
+public struct MomoText: View {
+    @Environment(\.appTheme) private var theme
+    @Environment(\.momoFontScale) private var fontScale
+    private let content: String
+    private let typography: TypographyStyle
+    private let color: Color?
+    private let textAlign: TextAlignment
+    private let maxLines: Int
+    private let minLines: Int
+    private let lineLimitRange: ClosedRange<Int>?
+    private let truncationMode: Text.TruncationMode
+    private let strikethrough: Bool
+    private let underline: Bool
+    private let letterSpacing: CGFloat?
+    private let softWrap: Bool
+    private let accessibilityId: String?
+    private var highlightText: [String] = []
+
+    public init(
+        _ content: String,
+        typography: TypographyStyle = .bodyDefaultRegular,
+        color: Color? = nil,
+        textAlign: TextAlignment = .leading,
+        maxLines: Int = Int.max,
+        minLines: Int = 1,
+        truncationMode: Text.TruncationMode = .tail,
+        strikethrough: Bool = false,
+        underline: Bool = false,
+        letterSpacing: CGFloat? = nil,
+        softWrap: Bool = true,
+        accessibilityId: String? = nil
+    ) {
+        self.content = content
+        self.typography = typography
+        self.color = color
+        self.textAlign = textAlign
+        self.maxLines = maxLines
+        self.minLines = minLines
+        // SwiftUI's range-based `lineLimit` is iOS 16+ only; keep the range for
+        // newer OS versions and fall back to the legacy single-value overload.
+        if maxLines == Int.max && minLines <= 1 {
+            self.lineLimitRange = nil
+        } else {
+            let upper = maxLines == Int.max ? Int.max : Swift.max(maxLines, minLines)
+            self.lineLimitRange = Swift.max(1, minLines)...upper
+        }
+        self.truncationMode = truncationMode
+        self.strikethrough = strikethrough
+        self.underline = underline
+        self.letterSpacing = letterSpacing
+        self.softWrap = softWrap
+        self.accessibilityId = accessibilityId
+    }
+
+    init(_ content: String, typography: TypographyStyle, highlightText: [String]) {
+        self.init(content, typography: typography)
+        self.highlightText = highlightText
+    }
+
+    // Whole-word matches of `highlightText` render semibold; the longest keyword wins (RN parity).
+    private var baseText: SwiftUI.Text {
+        let keywords = highlightText.filter { !$0.isEmpty }.sorted { $0.count > $1.count }
+        guard !keywords.isEmpty else { return SwiftUI.Text(content) }
+        let highlightFont = momoFont(size: fontScale(typography.fontSize), weight: TypographyStyle.headerXsSemibold.fontWeight, family: theme.font)
+        func isWordChar(_ character: Character?) -> Bool {
+            guard let character else { return false }
+            return character.isLetter || character.isNumber || character == "_"
+        }
+
+        var result = SwiftUI.Text(verbatim: "")
+        var plainStart = content.startIndex
+        var index = content.startIndex
+        while index < content.endIndex {
+            let previous = index > content.startIndex ? content[content.index(before: index)] : nil
+            let keyword = isWordChar(previous) ? nil : keywords.first { keyword in
+                guard content[index...].hasPrefix(keyword) else { return false }
+                let end = content.index(index, offsetBy: keyword.count)
+                return !isWordChar(end < content.endIndex ? content[end] : nil)
+            }
+            guard let keyword else {
+                index = content.index(after: index)
+                continue
+            }
+            let end = content.index(index, offsetBy: keyword.count)
+            result = result
+                + SwiftUI.Text(verbatim: String(content[plainStart..<index]))
+                + SwiftUI.Text(verbatim: String(content[index..<end])).font(highlightFont)
+            plainStart = end
+            index = end
+        }
+        return result + SwiftUI.Text(verbatim: String(content[plainStart...]))
+    }
+
+    public var body: some View {
+        let textColor = color ?? theme.colors.text.default
+        // Strikethrough is driven either by the typography variant (mirrors Compose
+        // *Strikethrough styles) or the explicit `strikethrough` flag.
+        let isStrikethrough = strikethrough || typography.isStrikethrough
+
+        var text = baseText
+            .font(momoFont(size: fontScale(typography.fontSize), weight: typography.fontWeight, family: theme.font))
+            .foregroundColor(textColor)
+            .strikethrough(isStrikethrough, color: textColor)
+            .underline(underline, color: textColor)
+
+        if let letterSpacing = letterSpacing {
+            text = text.tracking(letterSpacing)
+        }
+
+        return text
+            .multilineTextAlignment(textAlign)
+            .lineSpacing(fontScale(typography.lineHeight) - fontScale(typography.fontSize))
+            .modifier(LineLimitModifier(range: lineLimitRange))
+            .truncationMode(truncationMode)
+            .fixedSize(horizontal: !softWrap, vertical: false)
+            .accessibilityIdentifier(accessibilityId ?? content)
+            .ignoreBoldTextSetting()
+    }
+}
+
+// Applies a line-limit range only on iOS 16+. Older targets use the legacy
+// single-value overload so the file still compiles for iOS 15.
+private struct LineLimitModifier: ViewModifier {
+    let range: ClosedRange<Int>?
+
+    func body(content: Content) -> some View {
+        if let range = range {
+            if #available(iOS 16.0, *) {
+                content.lineLimit(range)
+            } else {
+                content.lineLimit(range.upperBound)
+            }
+        } else {
+            content
+        }
+    }
+}

package/ios/Typography/Typography.swift

@@ -1,30 +1,87 @@
 import SwiftUI
 
+public extension View {
+    /// Forces SwiftUI to ignore the OS "Bold Text" accessibility setting so the
+    /// kit's typography weight stays fixed and matches the Compose implementation
+    /// (which does not honor that OS setting). Apply it wherever a `.font(...)` is set.
+    func ignoreBoldTextSetting() -> some View {
+        environment(\.legibilityWeight, .regular)
+    }
+}
+
 public extension Font {
+    /// Non-reactive: resolves against the current `FontScaleStore` snapshot at each access. The
+    /// styles below are computed properties for that reason — as stored `static let`s they would
+    /// freeze the scale at first access and never pick up a Dynamic Type change.
+    /// Inside a view, `@Environment(\.momoFontScale)` + `fontScale.font(size:weight:)` also re-renders.
     static func appFont(size: CGFloat) -> Font {
-        return Font.custom("SFProText", size: size)
+        FontScaleStore.shared.snapshot.font(size: size)
     }
 
-    static let h1 = appFont(size: 36).weight(.semibold)
-    static let h2 = appFont(size: 32).weight(.semibold)
-    static let h3 = appFont(size: 28).weight(.semibold)
-    static let h4 = appFont(size: 24).weight(.semibold)
-    static let title1 = appFont(size: 20).weight(.bold)
-    static let title2 = appFont(size: 18).weight(.bold)
-    static let title3 = appFont(size: 16).weight(.bold)
-    static let headerText1 = appFont(size: 15).weight(.semibold)
-    static let headerText2 = appFont(size: 14).weight(.semibold)
-    static let headerText3 = appFont(size: 12).weight(.semibold)
-    static let paragraph = appFont(size: 15).weight(.regular)
-    static let description1 = appFont(size: 14).weight(.regular)
-    static let description2 = appFont(size: 12).weight(.regular)
-    static let description3 = appFont(size: 10).weight(.regular)
-    static let label1 = appFont(size: 14).weight(.medium)
-    static let label2 = appFont(size: 12).weight(.medium)
-    static let label3 = appFont(size: 10).weight(.medium)
-    static let label4 = appFont(size: 8).weight(.medium)
-    static let action1 = appFont(size: 16).weight(.bold)
-    static let action2 = appFont(size: 15).weight(.bold)
-    static let action3 = appFont(size: 12).weight(.bold)
-    static let action4 = appFont(size: 10).weight(.bold)
+    // New supported typography styles
+    static var headline_default_bold: Font { appFont(size: 24).weight(.bold) }
+    static var header_m_bold: Font { appFont(size: 18).weight(.bold) }
+    static var header_default_bold: Font { appFont(size: 16).weight(.bold) }
+    static var header_default_semibold: Font { appFont(size: 16).weight(.semibold) }
+    static var header_s_semibold: Font { appFont(size: 14).weight(.semibold) }
+    static var header_xs_semibold: Font { appFont(size: 12).weight(.semibold) }
+    static var body_default_regular: Font { appFont(size: 14).weight(.regular) }
+    static var description_default_regular: Font { appFont(size: 12).weight(.regular) }
+    static var description_xs_regular: Font { appFont(size: 10).weight(.regular) }
+    static var label_default_medium: Font { appFont(size: 14).weight(.medium) }
+    static var label_s_medium: Font { appFont(size: 12).weight(.medium) }
+    static var label_xs_medium: Font { appFont(size: 10).weight(.medium) }
+    static var action_default_bold: Font { appFont(size: 16).weight(.bold) }
+    static var action_s_bold: Font { appFont(size: 14).weight(.bold) }
+    static var action_xs_bold: Font { appFont(size: 12).weight(.bold) }
+    static var action_xxs_bold: Font { appFont(size: 10).weight(.bold) }
+
+    // Legacy styles
+    static var headline_default: Font { appFont(size: 28).weight(.semibold) }
+    static var headline_s: Font { appFont(size: 24).weight(.semibold) }
+    static var headline_l: Font { appFont(size: 32).weight(.semibold) }
+    static var headline_xl: Font { appFont(size: 36).weight(.semibold) }
+    static var title_default: Font { appFont(size: 20).weight(.bold) }
+    static var title_xs: Font { appFont(size: 16).weight(.bold) }
+    static var title_s: Font { appFont(size: 18).weight(.bold) }
+    static var header_default: Font { appFont(size: 15).weight(.semibold) }
+    static var header_xs: Font { appFont(size: 12).weight(.semibold) }
+    static var header_s: Font { appFont(size: 14).weight(.semibold) }
+    static var paragraph_default: Font { appFont(size: 15).weight(.regular) }
+    static var paragraph_bold: Font { appFont(size: 15).weight(.bold) }
+    static var description_default: Font { appFont(size: 14).weight(.regular) }
+    static var description_xs: Font { appFont(size: 10).weight(.regular) }
+    static var description_s: Font { appFont(size: 12).weight(.regular) }
+    static var label_default: Font { appFont(size: 14).weight(.medium) }
+    static var label_xxs: Font { appFont(size: 8).weight(.medium) }
+    static var label_xs: Font { appFont(size: 10).weight(.medium) }
+    static var label_s: Font { appFont(size: 12).weight(.medium) }
+    static var action_default: Font { appFont(size: 16).weight(.bold) }
+    static var action_xxs: Font { appFont(size: 10).weight(.bold) }
+    static var action_xs: Font { appFont(size: 12).weight(.bold) }
+    static var action_s: Font { appFont(size: 15).weight(.bold) }
+
+    // deprecated
+    static var h1: Font { appFont(size: 36).weight(.semibold) } //headline_xl
+    static var h2: Font { appFont(size: 32).weight(.semibold) }
+    static var h3: Font { appFont(size: 28).weight(.semibold) }
+    static var h4: Font { appFont(size: 24).weight(.semibold) }
+    static var title1: Font { appFont(size: 20).weight(.bold) }
+    static var title2: Font { appFont(size: 18).weight(.bold) }
+    static var title3: Font { appFont(size: 16).weight(.bold) }
+    static var headerText1: Font { appFont(size: 15).weight(.semibold) } //header_default
+    static var headerText2: Font { appFont(size: 14).weight(.semibold) }
+    static var headerText3: Font { appFont(size: 12).weight(.semibold) }
+    static var paragraph: Font { appFont(size: 15).weight(.regular) } //paragraph_default
+    static var description1: Font { appFont(size: 14).weight(.regular) }
+    static var description2: Font { appFont(size: 12).weight(.regular) }
+    static var description3: Font { appFont(size: 10).weight(.regular) }
+    static var label1: Font { appFont(size: 14).weight(.medium) }
+    static var label2: Font { appFont(size: 12).weight(.medium) }
+    static var label3: Font { appFont(size: 10).weight(.medium) }
+    static var label4: Font { appFont(size: 8).weight(.medium) }
+    static var action1: Font { appFont(size: 16).weight(.bold) }
+    static var action2: Font { appFont(size: 15).weight(.bold) }
+    static var action3: Font { appFont(size: 12).weight(.bold) }
+    static var action4: Font { appFont(size: 10).weight(.bold) }
 }

package/ios/Uploader/Uploader.swift

@@ -0,0 +1,174 @@
+import SwiftUI
+
+/// Native SwiftUI port of the Compose `Uploader` component.
+///
+/// Renders a horizontal row with an optional dashed "add image" picker cell
+/// followed by a horizontally scrollable list of uploaded image thumbnails.
+/// Each thumbnail can show a loading shimmer overlay and an optional cancel
+/// button.
+///
+/// Mirrors the Compose surface in
+/// `compose/.../components/Uploader.kt`:
+/// - `images`, `numberOfImages`, `disabled`, `width`, `height`
+/// - callbacks `onAdd`, `onCancel`, `onPressImage`
+///
+/// Note: like Compose, this component does NOT perform any native photo-picker
+/// or file-system access. It exposes the `onAdd` callback so the host can
+/// present a picker and supply the resulting image data back via the `images`
+/// list (the demo passes mock image URLs).
+public struct UploadImage: Identifiable {
+    public let id = UUID()
+    public var uri: String?
+    public var loading: Bool
+
+    public init(uri: String? = nil, loading: Bool = false) {
+        self.uri = uri
+        self.loading = loading
+    }
+}
+
+public struct Uploader: View {
+    // MARK: Properties
+
+    private let images: [UploadImage]
+    private let numberOfImages: Int
+    private let disabled: Bool
+    private let width: CGFloat
+    private let height: CGFloat
+    private let onAdd: () -> Void
+    private let onCancel: ((UploadImage, Int) -> Void)?
+    private let onPressImage: (UploadImage, Int) -> Void
+
+    // MARK: Lifecycle
+
+    public init(
+        images: [UploadImage],
+        numberOfImages: Int = 1,
+        disabled: Bool = false,
+        width: CGFloat = 64,
+        height: CGFloat = 64,
+        onAdd: @escaping () -> Void = {},
+        onCancel: ((UploadImage, Int) -> Void)? = nil,
+        onPressImage: @escaping (UploadImage, Int) -> Void = { _, _ in }
+    ) {
+        self.images = images
+        self.numberOfImages = numberOfImages
+        self.disabled = disabled
+        self.width = width
+        self.height = height
+        self.onAdd = onAdd
+        self.onCancel = onCancel
+        self.onPressImage = onPressImage
+    }
+
+    // MARK: Body
+
+    private var shouldShowPicker: Bool {
+        images.count < numberOfImages
+    }
+
+    public var body: some View {
+        HStack(alignment: .top, spacing: Spacing.S) {
+            if shouldShowPicker {
+                UploaderPickerCell(
+                    disabled: disabled,
+                    width: width,
+                    height: height,
+                    onAdd: onAdd
+                )
+            }
+
+            ScrollView(.horizontal, showsIndicators: false) {
+                HStack(alignment: .top, spacing: Spacing.S) {
+                    ForEach(Array(images.enumerated()), id: \.element.id) { index, image in
+                        UploaderImageItem(
+                            image: image,
+                            width: width,
+                            height: height,
+                            index: index,
+                            onCancel: onCancel,
+                            onPressImage: { onPressImage(image, index) }
+                        )
+                    }
+                }
+            }
+        }
+    }
+}
+
+// MARK: - Picker cell
+
+private struct UploaderPickerCell: View {
+    @Environment(\.appTheme) private var theme
+
+    let disabled: Bool
+    let width: CGFloat
+    let height: CGFloat
+    let onAdd: () -> Void
+
+    // text.disable / text.hint and border.disable / border.default tokens.
+    private var mainColor: Color { disabled ? theme.colors.text.disable : theme.colors.text.hint }
+    private var borderColor: Color { disabled ? theme.colors.border.disable : theme.colors.border.default }
+
+    var body: some View {
+        SwiftUI.Button(action: { if !disabled { onAdd() } }) {
+            VStack(spacing: Spacing.XXS) {
+                Icon(source: "16_navigation_plus", size: 16, color: mainColor)
+                MomoText("Thêm hình", typography: .descriptionXsRegular, color: mainColor)
+            }
+            .frame(width: width, height: height)
+            .background(
+                RoundedRectangle(cornerRadius: Radius.XS)
+                    .strokeBorder(
+                        borderColor,
+                        style: StrokeStyle(lineWidth: 1, dash: [10, 6])
+                    )
+            )
+            .clipShape(RoundedRectangle(cornerRadius: Radius.XS))
+        }
+        .buttonStyle(ActiveOpacityButtonStyle())
+        .disabled(disabled)
+    }
+}
+
+// MARK: - Image item
+
+private struct UploaderImageItem: View {
+    let image: UploadImage
+    let width: CGFloat
+    let height: CGFloat
+    let index: Int
+    let onCancel: ((UploadImage, Int) -> Void)?
+    let onPressImage: () -> Void
+
+    var body: some View {
+        SwiftUI.Button(action: onPressImage) {
+            ZStack(alignment: .topTrailing) {
+                ImageView(image.uri ?? "", contentMode: .fill)
+                    .frame(width: width, height: height)
+                    .clipShape(RoundedRectangle(cornerRadius: Radius.XS))
+
+                if image.loading {
+                    Skeleton()
+                        .frame(width: width, height: height)
+                        .clipShape(RoundedRectangle(cornerRadius: Radius.XS))
+                        .background(
+                            Color.white.opacity(0.4)
+                                .clipShape(RoundedRectangle(cornerRadius: Radius.XS))
+                        )
+                }
+
+                if let onCancel, !image.loading {
+                    SwiftUI.Button(action: { onCancel(image, index) }) {
+                        Icon(source: "navigation_close_circle_full", size: 16, color: nil)
+                    }
+                    .buttonStyle(ActiveOpacityButtonStyle())
+                    .padding(.top, Spacing.XXS)
+                    .padding(.trailing, Spacing.XXS)
+                }
+            }
+            .frame(width: width, height: height)
+        }
+        .buttonStyle(ActiveOpacityButtonStyle())
+    }
+}

package/ios/native-kits.podspec

@@ -1,17 +1,75 @@
-Pod::Spec.new do |spec|
-    spec.name          = 'MoMoUIKits'
-    spec.version       = '1.0.0'
-    spec.license       = { :type => 'MIT', :file => 'LICENSE' }
-    spec.homepage      = 'https://gitlab.com'
-    spec.authors       = { 'Developer' => 'momo@mservice.com.vn' }
-    spec.summary       = 'Components for SwiftUI'
-    spec.source        = { :git => 'https://gitlab.com', :tag => 'v1.0.0' }
-    spec.swift_versions = ['5.0']
-    spec.ios.deployment_target  = '13.0'
+Pod::Spec.new do |s|
+  s.name             = 'MoMoUIKits'
+  s.version          = '0.167.1-beta.4'
+  s.summary          = 'MoMoUIKits for iOS'
+  s.homepage         = 'https://momo.vn'
+  s.license          = { :type => 'MIT' }
+  s.author           = { 'MoMo' => 'dev@momo.vn' }
+  s.source           = { :path => '.' }
 
-    spec.source_files   = "**/*.swift"
+  s.ios.deployment_target = '15.0'
+  s.swift_version         = '5.0'
+  s.module_name           = 'MoMoUIKits'
 
-    spec.framework      = 'SwiftUI', 'Combine'
-    spec.dependency       'SDWebImageSwiftUI'
-    spec.dependency       'SkeletonUI'
-  end
+  s.source_files       = [
+    "Application/**/*.{swift,m,h}",
+    "Avatar/**/*.{swift,m,h}",
+    "Badge/**/*.{swift,m,h}",
+    "BaselineView/**/*.{swift,m,h}",
+    "Button/**/*.{swift,m,h}",
+    "CalculatorKeyboard/**/*.{swift,m,h}",
+    "Carousel/**/*.{swift,m,h}",
+    "Checkbox/**/*.{swift,m,h}",
+    "Chip/**/*.{swift,m,h}",
+    "Collapse/**/*.{swift,m,h}",
+    "Colors+Radius+Spacing/**/*.{swift,m,h}",
+    "DateTimePicker/**/*.{swift,m,h}",
+    "Divider/**/*.{swift,m,h}",
+    "Extensions/**/*.{swift,m,h}",
+    "Icon/**/*.{swift,m,h}",
+    "IconButton/**/*.{swift,m,h}",
+    "Image/**/*.{swift,m,h}",
+    "Information/**/*.{swift,m,h}",
+    "Input/**/*.{swift,m,h}",
+    "InputDropDown/**/*.{swift,m,h}",
+    "InputMoney/**/*.{swift,m,h}",
+    "InputOTP/**/*.{swift,m,h}",
+    "Layout/**/*.{swift,m,h}",
+    "Loader/**/*.{swift,m,h}",
+    "Lottie/**/*.{swift,m,h}",
+    "OTPKeyboard/**/*.{swift,m,h}",
+    "Pagination/**/*.{swift,m,h}",
+    "Popup/**/*.{swift,m,h}",
+    "PopupView/**/*.{swift,m,h}",
+    "ProgressInfo/**/*.{swift,m,h}",
+    "Radio/**/*.{swift,m,h}",
+    "Rating/**/*.{swift,m,h}",
+    "ScrollIndicator/**/*.{swift,m,h}",
+    "Skeleton/**/*.{swift,m,h}",
+    "Slider/**/*.{swift,m,h}",
+    "StatusBarTap/**/*.{swift,m,h}",
+    "Stepper/**/*.{swift,m,h}",
+    "Steps/**/*.{swift,m,h}",
+    "SuggestAction/**/*.{swift,m,h}",
+    "Swipeable/**/*.{swift,m,h}",
+    "Switch/**/*.{swift,m,h}",
+    "TabView/**/*.{swift,m,h}",
+    "Tag/**/*.{swift,m,h}",
+    "Template/**/*.{swift,m,h}",
+    "Title/**/*.{swift,m,h}",
+    "Tooltip/**/*.{swift,m,h}",
+    "Typography/**/*.{swift,m,h}",
+    "Uploader/**/*.{swift,m,h}"
+  ]
+  s.resource_bundles = {
+    'MoMoUIKitsResources' => ['Resources/**/*']
+  }
+  s.public_header_files = "StatusBarTap/*.h"
+  s.frameworks             = 'SwiftUI', 'Combine'
+  s.pod_target_xcconfig = {
+    'DEFINES_MODULE' => 'YES'
+  }
+  s.dependency  'SDWebImageSwiftUI', '2.2.1'
+  s.dependency       'lottie-ios', '4.6.0'
+  s.dependency  'SkeletonUI', '1.0.11'
+end

package/ios-demo/MoMoUIKitsDemo.podspec

@@ -0,0 +1,20 @@
+Pod::Spec.new do |s|
+  s.name             = 'MoMoUIKitsDemo'
+  s.version          = '0.167.1-beta.4'
+  s.summary          = 'Demo browser for MoMoUIKits SwiftUI components'
+  s.homepage         = 'https://momo.vn'
+  s.license          = { :type => 'MIT' }
+  s.author           = { 'MoMo' => 'dev@momo.vn' }
+  s.source           = { :path => '.' }
+
+  s.ios.deployment_target = '15.0'
+  s.swift_version         = '5.0'
+
+  s.source_files = 'Sources/**/*.{swift}'
+  s.resource_bundles = {
+    'MoMoUIKitsDemoResources' => ['Resources/**/*']
+  }
+  s.frameworks   = 'SwiftUI', 'UIKit'
+  s.dependency 'MoMoUIKits'
+  s.dependency 'lottie-ios', '4.6.0'
+end