@momo-kits/native-kits 0.169.14 → 0.169.15-beta.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/ios/Navigation/BottomTab/BottomTab.swift +22 -3
- package/ios/Navigation/BottomTab/DuoTabBar.swift +2 -0
- package/ios/Navigation/BottomTab/LegacyBottomTabBar.swift +226 -0
- package/ios/Navigation/StackScreen.swift +2 -1
- package/ios/native-kits.podspec +1 -1
- package/ios-demo/MoMoUIKitsDemo.podspec +1 -1
- package/ios-demo/Sources/MoMoUIKitsDemo/SampleDemos/BottomTabDemo.swift +5 -1
- package/package.json +1 -1
|
@@ -10,6 +10,7 @@ public struct BottomTab: View {
|
|
|
10
10
|
private let compressionBehavior: DuoBarCompressionBehavior
|
|
11
11
|
private let onTabPress: ((_ index: Int, _ switchTab: @escaping () -> Void) -> Void)?
|
|
12
12
|
private let backToInitialTab: Bool
|
|
13
|
+
private let useLegacy: Bool
|
|
13
14
|
|
|
14
15
|
@EnvironmentObject private var navigator: Navigator
|
|
15
16
|
/// The screen hosting the tabs (Compose's `LocalNavigation` in BottomTab).
|
|
@@ -26,19 +27,22 @@ public struct BottomTab: View {
|
|
|
26
27
|
|
|
27
28
|
/// `compressionBehavior`: iPhone Duo bar that starts compressed when the side bar can't hold both (a tap swaps).
|
|
28
29
|
/// `onTabPress` gets the switch to run, e.g. after a login gate. `backToInitialTab`: back goes to it first.
|
|
30
|
+
/// `useLegacy`: the pre-redesign phone bar (full width, content kept above it; edge to edge ignored).
|
|
29
31
|
public init(
|
|
30
32
|
items: [BottomTabItem],
|
|
31
33
|
floatingButton: BottomTabFloatingButton? = nil,
|
|
32
34
|
compressionBehavior: DuoBarCompressionBehavior = .toolbar,
|
|
33
35
|
initialRouteName: String? = nil,
|
|
34
36
|
onTabPress: ((_ index: Int, _ switchTab: @escaping () -> Void) -> Void)? = nil,
|
|
35
|
-
backToInitialTab: Bool = true
|
|
37
|
+
backToInitialTab: Bool = true,
|
|
38
|
+
useLegacy: Bool = false
|
|
36
39
|
) {
|
|
37
40
|
self.items = items
|
|
38
41
|
self.floatingButton = floatingButton
|
|
39
42
|
self.compressionBehavior = compressionBehavior
|
|
40
43
|
self.onTabPress = onTabPress
|
|
41
44
|
self.backToInitialTab = backToInitialTab
|
|
45
|
+
self.useLegacy = useLegacy
|
|
42
46
|
let start = items.firstIndex { $0.name == initialRouteName } ?? 0
|
|
43
47
|
_startIndex = State(initialValue: start)
|
|
44
48
|
_selectedIndex = State(initialValue: start)
|
|
@@ -47,7 +51,13 @@ public struct BottomTab: View {
|
|
|
47
51
|
private var bottomInset: CGFloat { safeAreaBottomInset() }
|
|
48
52
|
// the bars float over the content (tab screens keep clear of them through duoTabBarInsets) or sit
|
|
49
53
|
// in the side strip, so only the home indicator is kept clear
|
|
50
|
-
|
|
54
|
+
// the legacy bar sits under the content, which keeps clear of all of it
|
|
55
|
+
private var reservedBottom: CGFloat {
|
|
56
|
+
isLegacyBar ? LEGACY_BOTTOM_TAB_BAR_HEIGHT + bottomInset + Spacing.S : layout.insets.bottom
|
|
57
|
+
}
|
|
58
|
+
|
|
59
|
+
/// Legacy covers the phone bar only; the iPhone Duo keeps its rail / floating bar.
|
|
60
|
+
private var isLegacyBar: Bool { useLegacy && !layout.isIPhoneDuo }
|
|
51
61
|
|
|
52
62
|
private var compression: DuoBarCompression {
|
|
53
63
|
DuoBarCompression.resolve(
|
|
@@ -68,7 +78,8 @@ public struct BottomTab: View {
|
|
|
68
78
|
}
|
|
69
79
|
|
|
70
80
|
private func duoInsets(_ compression: DuoBarCompression) -> DuoTabBarInsets {
|
|
71
|
-
|
|
81
|
+
if isLegacyBar { return DuoTabBarInsets(isLegacyBar: true) }
|
|
82
|
+
return layout.duoTabBarInsets(
|
|
72
83
|
itemCount: items.count,
|
|
73
84
|
hasFloatingButton: floatingButton != nil,
|
|
74
85
|
tabBarCompressed: compression.tabBarCompressed
|
|
@@ -94,6 +105,14 @@ public struct BottomTab: View {
|
|
|
94
105
|
onTabSelected: selectTab,
|
|
95
106
|
compression: compression
|
|
96
107
|
)
|
|
108
|
+
} else if isLegacyBar {
|
|
109
|
+
LegacyBottomTabBar(
|
|
110
|
+
items: items,
|
|
111
|
+
floatingButton: floatingButton,
|
|
112
|
+
selectedIndex: selectedIndex,
|
|
113
|
+
onTabSelected: selectTab,
|
|
114
|
+
bottomInset: bottomInset
|
|
115
|
+
)
|
|
97
116
|
} else {
|
|
98
117
|
BottomTabBar(
|
|
99
118
|
items: items,
|
|
@@ -11,6 +11,8 @@ struct DuoTabBarInsets: Equatable {
|
|
|
11
11
|
var overlay: CGFloat = 0
|
|
12
12
|
/// Rail sits at the bottom of the side strip: the header side bar stays this far above the window bottom.
|
|
13
13
|
var sideBarReserve: CGFloat = 0
|
|
14
|
+
/// `BottomTab(useLegacy: true)`: the bar sits under the content, so a tab can't run edge to edge behind it.
|
|
15
|
+
var isLegacyBar = false
|
|
14
16
|
}
|
|
15
17
|
|
|
16
18
|
private struct DuoTabBarInsetsKey: EnvironmentKey {
|
|
@@ -0,0 +1,226 @@
|
|
|
1
|
+
// The pre-redesign (DS-984) phone tab bar, kept for `BottomTab(useLegacy: true)`: a full-width surface bar with a
|
|
2
|
+
// sliding top indicator, a top shadow, badges and the notched center floating button, over a home-indicator filler.
|
|
3
|
+
|
|
4
|
+
import SwiftUI
|
|
5
|
+
|
|
6
|
+
let LEGACY_BOTTOM_TAB_BAR_HEIGHT: CGFloat = 64
|
|
7
|
+
private let legacyFloatingButtonWidth: CGFloat = 75
|
|
8
|
+
|
|
9
|
+
/// The legacy bar plus its surface filler under it, down to the window bottom.
|
|
10
|
+
struct LegacyBottomTabBar: View {
|
|
11
|
+
let items: [BottomTabItem]
|
|
12
|
+
let floatingButton: BottomTabFloatingButton?
|
|
13
|
+
let selectedIndex: Int
|
|
14
|
+
let onTabSelected: (Int) -> Void
|
|
15
|
+
let bottomInset: CGFloat
|
|
16
|
+
|
|
17
|
+
@Environment(\.screenLayout) private var layout
|
|
18
|
+
@Environment(\.appTheme) private var theme
|
|
19
|
+
|
|
20
|
+
// the bar sits between the side safe areas
|
|
21
|
+
private var screenWidth: CGFloat { layout.width - layout.insets.leading - layout.insets.trailing }
|
|
22
|
+
private var mid: Int { items.count / 2 }
|
|
23
|
+
|
|
24
|
+
private var tabWidth: CGFloat {
|
|
25
|
+
let available = floatingButton != nil ? screenWidth - legacyFloatingButtonWidth : screenWidth
|
|
26
|
+
return available / CGFloat(max(items.count, 1))
|
|
27
|
+
}
|
|
28
|
+
|
|
29
|
+
private var indicatorOffset: CGFloat {
|
|
30
|
+
let adjust: CGFloat = (floatingButton != nil && selectedIndex >= mid) ? legacyFloatingButtonWidth : 0
|
|
31
|
+
return tabWidth * CGFloat(selectedIndex) + tabWidth / 2 - screenWidth / 2 + adjust
|
|
32
|
+
}
|
|
33
|
+
|
|
34
|
+
var body: some View {
|
|
35
|
+
VStack(spacing: 0) {
|
|
36
|
+
bar
|
|
37
|
+
theme.colors.background.surface
|
|
38
|
+
.frame(height: bottomInset + Spacing.S)
|
|
39
|
+
.ignoresSafeArea(edges: .horizontal)
|
|
40
|
+
}
|
|
41
|
+
}
|
|
42
|
+
|
|
43
|
+
private var bar: some View {
|
|
44
|
+
ZStack(alignment: .bottom) {
|
|
45
|
+
HStack(spacing: 0) {
|
|
46
|
+
if floatingButton == nil {
|
|
47
|
+
tabItems(from: 0, to: items.count)
|
|
48
|
+
} else {
|
|
49
|
+
tabItems(from: 0, to: mid)
|
|
50
|
+
Spacer()
|
|
51
|
+
.frame(width: legacyFloatingButtonWidth)
|
|
52
|
+
.padding(.horizontal, Spacing.XXS)
|
|
53
|
+
tabItems(from: mid, to: items.count)
|
|
54
|
+
}
|
|
55
|
+
}
|
|
56
|
+
.frame(maxWidth: .infinity)
|
|
57
|
+
.frame(height: LEGACY_BOTTOM_TAB_BAR_HEIGHT)
|
|
58
|
+
.background(theme.colors.background.surface.ignoresSafeArea(edges: .horizontal))
|
|
59
|
+
|
|
60
|
+
RoundedRectangle(cornerRadius: 2)
|
|
61
|
+
.fill(theme.colors.primary)
|
|
62
|
+
.frame(width: 44, height: 2)
|
|
63
|
+
.offset(x: indicatorOffset, y: -LEGACY_BOTTOM_TAB_BAR_HEIGHT + 2)
|
|
64
|
+
.animation(.easeInOut(duration: 0.25), value: selectedIndex)
|
|
65
|
+
|
|
66
|
+
LinearGradient(colors: [Color.black.opacity(0.05), .clear], startPoint: .bottom, endPoint: .top)
|
|
67
|
+
.frame(height: 6)
|
|
68
|
+
.frame(maxWidth: .infinity)
|
|
69
|
+
.offset(y: -LEGACY_BOTTOM_TAB_BAR_HEIGHT)
|
|
70
|
+
|
|
71
|
+
if let floatingButton {
|
|
72
|
+
LegacyCenterFloatingButton(data: floatingButton)
|
|
73
|
+
}
|
|
74
|
+
}
|
|
75
|
+
}
|
|
76
|
+
|
|
77
|
+
@ViewBuilder
|
|
78
|
+
private func tabItems(from: Int, to: Int) -> some View {
|
|
79
|
+
ForEach(from..<to, id: \.self) { index in
|
|
80
|
+
LegacyTabBarItem(
|
|
81
|
+
item: items[index],
|
|
82
|
+
selected: index == selectedIndex,
|
|
83
|
+
// from the icon's center to the cell's end edge, inside both XXS paddings
|
|
84
|
+
badgeMaxWidth: tabWidth / 2 - Spacing.XXS * 2,
|
|
85
|
+
onClick: { onTabSelected(index) }
|
|
86
|
+
)
|
|
87
|
+
.frame(maxWidth: .infinity)
|
|
88
|
+
}
|
|
89
|
+
}
|
|
90
|
+
}
|
|
91
|
+
|
|
92
|
+
private struct LegacyTabBarItem: View {
|
|
93
|
+
let item: BottomTabItem
|
|
94
|
+
let selected: Bool
|
|
95
|
+
let badgeMaxWidth: CGFloat
|
|
96
|
+
let onClick: () -> Void
|
|
97
|
+
|
|
98
|
+
@Environment(\.appTheme) private var theme
|
|
99
|
+
|
|
100
|
+
private var tintColor: Color { selected ? theme.colors.primary : theme.colors.text.hint }
|
|
101
|
+
|
|
102
|
+
/// Compose's `formatLabel`: a badge that is the number "0" is hidden.
|
|
103
|
+
private var badgeLabel: String? {
|
|
104
|
+
guard let label = item.badgeLabel else { return nil }
|
|
105
|
+
if let number = Int(label), number == 0 { return nil }
|
|
106
|
+
return label
|
|
107
|
+
}
|
|
108
|
+
|
|
109
|
+
var body: some View {
|
|
110
|
+
VStack(spacing: 0) {
|
|
111
|
+
Icon(source: item.icon, size: 28, color: tintColor)
|
|
112
|
+
.overlay(alignment: .topLeading) {
|
|
113
|
+
// starts at the icon's center and grows toward the cell's end edge, ellipsized past it
|
|
114
|
+
if let badgeLabel, !badgeLabel.isEmpty {
|
|
115
|
+
Badge(label: badgeLabel)
|
|
116
|
+
.frame(width: max(badgeMaxWidth, 0), alignment: .leading)
|
|
117
|
+
.offset(x: 14, y: -Spacing.S)
|
|
118
|
+
}
|
|
119
|
+
}
|
|
120
|
+
.overlay(alignment: .topTrailing) {
|
|
121
|
+
if badgeLabel?.isEmpty == true || (badgeLabel == nil && item.showDot) {
|
|
122
|
+
BadgeDot(size: .small).offset(x: 4, y: -4)
|
|
123
|
+
}
|
|
124
|
+
}
|
|
125
|
+
.padding(Spacing.XS)
|
|
126
|
+
MomoText(
|
|
127
|
+
item.label,
|
|
128
|
+
typography: selected ? .labelXsMedium : .descriptionXsRegular,
|
|
129
|
+
color: tintColor,
|
|
130
|
+
textAlign: .center,
|
|
131
|
+
maxLines: 1
|
|
132
|
+
)
|
|
133
|
+
.truncationMode(.tail)
|
|
134
|
+
}
|
|
135
|
+
.frame(maxWidth: .infinity, maxHeight: .infinity)
|
|
136
|
+
.padding(Spacing.S)
|
|
137
|
+
.frame(maxWidth: .infinity, maxHeight: .infinity)
|
|
138
|
+
.padding(.horizontal, Spacing.XXS)
|
|
139
|
+
.contentShape(Rectangle())
|
|
140
|
+
.onTapGesture { onClick() }
|
|
141
|
+
}
|
|
142
|
+
}
|
|
143
|
+
|
|
144
|
+
/// The 48 primary circle in the bar's notch; `iconContent` replaces the icon, `labelContent` overlays the label.
|
|
145
|
+
private struct LegacyCenterFloatingButton: View {
|
|
146
|
+
let data: BottomTabFloatingButton
|
|
147
|
+
|
|
148
|
+
@Environment(\.appTheme) private var theme
|
|
149
|
+
|
|
150
|
+
var body: some View {
|
|
151
|
+
VStack(spacing: 0) {
|
|
152
|
+
LegacyCurvedContainer()
|
|
153
|
+
Circle()
|
|
154
|
+
.fill(theme.colors.primary)
|
|
155
|
+
.frame(width: 48, height: 48)
|
|
156
|
+
.overlay(icon)
|
|
157
|
+
Spacer().frame(height: 4)
|
|
158
|
+
MomoText(data.label, typography: .labelXsMedium, color: Colors.black01, textAlign: .center, maxLines: 1)
|
|
159
|
+
.frame(maxWidth: .infinity)
|
|
160
|
+
.frame(height: 14)
|
|
161
|
+
.background(theme.colors.primary)
|
|
162
|
+
.clipShape(RoundedRectangle(cornerRadius: Radius.XL))
|
|
163
|
+
.overlay(data.labelContent)
|
|
164
|
+
}
|
|
165
|
+
.frame(width: legacyFloatingButtonWidth)
|
|
166
|
+
.padding(.horizontal, Spacing.XXS)
|
|
167
|
+
.padding(.vertical, Spacing.S)
|
|
168
|
+
.contentShape(Rectangle())
|
|
169
|
+
.onTapGesture { data.onPress() }
|
|
170
|
+
}
|
|
171
|
+
|
|
172
|
+
@ViewBuilder
|
|
173
|
+
private var icon: some View {
|
|
174
|
+
if let iconContent = data.iconContent {
|
|
175
|
+
iconContent
|
|
176
|
+
} else {
|
|
177
|
+
Icon(source: data.icon, size: 28, color: .white)
|
|
178
|
+
}
|
|
179
|
+
}
|
|
180
|
+
}
|
|
181
|
+
|
|
182
|
+
/// Compose's legacy `CurvedContainer`: the surface notch carved into the bar's top edge behind the center button.
|
|
183
|
+
private struct LegacyCurvedContainer: View {
|
|
184
|
+
private let circleSize: CGFloat = 48
|
|
185
|
+
private let iconSize: CGFloat = 28
|
|
186
|
+
private let circleOverSize: CGFloat = 2
|
|
187
|
+
private let width: CGFloat = 71
|
|
188
|
+
private let height: CGFloat = 16
|
|
189
|
+
|
|
190
|
+
var body: some View {
|
|
191
|
+
let circleOverTop = circleSize - iconSize - 10 + circleOverSize
|
|
192
|
+
LegacyCurvedShape(circleOverTop: circleOverTop, centerX: width / 2, circleOverR: circleSize / 2 + circleOverSize)
|
|
193
|
+
.fill(Colors.black01)
|
|
194
|
+
.frame(width: width, height: height)
|
|
195
|
+
.offset(y: 24)
|
|
196
|
+
.zIndex(-1)
|
|
197
|
+
}
|
|
198
|
+
}
|
|
199
|
+
|
|
200
|
+
/// A flat bar with a smooth circular dip in the middle, sized to cradle the floating button.
|
|
201
|
+
private struct LegacyCurvedShape: Shape {
|
|
202
|
+
let circleOverTop: CGFloat
|
|
203
|
+
let centerX: CGFloat
|
|
204
|
+
let circleOverR: CGFloat
|
|
205
|
+
|
|
206
|
+
func path(in rect: CGRect) -> Path {
|
|
207
|
+
var path = Path()
|
|
208
|
+
path.move(to: CGPoint(x: 0, y: circleOverTop))
|
|
209
|
+
path.addLine(to: CGPoint(x: centerX - circleOverR - 40, y: circleOverTop))
|
|
210
|
+
path.addCurve(
|
|
211
|
+
to: CGPoint(x: centerX, y: 0),
|
|
212
|
+
control1: CGPoint(x: centerX - circleOverR, y: circleOverTop),
|
|
213
|
+
control2: CGPoint(x: centerX - circleOverR, y: 0)
|
|
214
|
+
)
|
|
215
|
+
path.addCurve(
|
|
216
|
+
to: CGPoint(x: centerX + circleOverR + 40, y: circleOverTop),
|
|
217
|
+
control1: CGPoint(x: centerX + circleOverR, y: 0),
|
|
218
|
+
control2: CGPoint(x: centerX + circleOverR, y: circleOverTop)
|
|
219
|
+
)
|
|
220
|
+
path.addLine(to: CGPoint(x: rect.width, y: circleOverTop))
|
|
221
|
+
path.addLine(to: CGPoint(x: rect.width, y: 60))
|
|
222
|
+
path.addLine(to: CGPoint(x: 0, y: 60))
|
|
223
|
+
path.closeSubpath()
|
|
224
|
+
return path
|
|
225
|
+
}
|
|
226
|
+
}
|
|
@@ -167,7 +167,8 @@ public struct StackScreen<Content: View>: View {
|
|
|
167
167
|
/// (`floatingTabBarEdgeToEdge()`), when it also covers the home indicator that BottomTab keeps clear of
|
|
168
168
|
/// (a negative inset extends the content past the tab's frame).
|
|
169
169
|
private var contentBottomInset: CGFloat {
|
|
170
|
-
guard let navigation, navigation.bottomTabIndex != -1, navigation.bottomTabEdgeToEdge
|
|
170
|
+
guard let navigation, navigation.bottomTabIndex != -1, navigation.bottomTabEdgeToEdge,
|
|
171
|
+
!duoTabBarInsets.isLegacyBar else {
|
|
171
172
|
return duoTabBarInsets.overlay
|
|
172
173
|
}
|
|
173
174
|
return -layout.insets.bottom
|
package/ios/native-kits.podspec
CHANGED
|
@@ -38,6 +38,7 @@ private struct DemoConfig: Hashable {
|
|
|
38
38
|
var ctaLottie = false
|
|
39
39
|
var initialRouteName = "Momo"
|
|
40
40
|
var compressionBehavior: DuoBarCompressionBehavior = .toolbar
|
|
41
|
+
var useLegacy = false
|
|
41
42
|
var backToInitialTab = true
|
|
42
43
|
// a sticky footer in the tab's content body, to check it clears the floating bar
|
|
43
44
|
var footer = false
|
|
@@ -134,7 +135,8 @@ struct BottomTabDemoContent: View {
|
|
|
134
135
|
focused = tabs[index].name
|
|
135
136
|
switchTab()
|
|
136
137
|
},
|
|
137
|
-
backToInitialTab: config.backToInitialTab
|
|
138
|
+
backToInitialTab: config.backToInitialTab,
|
|
139
|
+
useLegacy: config.useLegacy
|
|
138
140
|
)
|
|
139
141
|
.id(config)
|
|
140
142
|
.onAppear { ctaLottieLoader.load() }
|
|
@@ -222,6 +224,8 @@ private struct TabContent: View {
|
|
|
222
224
|
config.compressionBehavior = .tabBar
|
|
223
225
|
},
|
|
224
226
|
])
|
|
227
|
+
Options(title: "useLegacy", hint: "Thanh tab cũ (trước redesign), iPhone thường",
|
|
228
|
+
options: yesNo(config.useLegacy) { config.useLegacy = $0 })
|
|
225
229
|
Options(title: "backToInitialTab", hint: "Back ở tab khác quay về tab đầu trước khi rời màn",
|
|
226
230
|
options: yesNo(config.backToInitialTab) { config.backToInitialTab = $0 })
|
|
227
231
|
Options(title: "footer",
|