@bzbs/react-providers
Version:
A collection of React Context Provider for Buzzebees apps
1,598 lines (1,582 loc) • 132 kB
JavaScript
var __defProp = Object.defineProperty;
var __defProps = Object.defineProperties;
var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
var __getOwnPropSymbols = Object.getOwnPropertySymbols;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __propIsEnum = Object.prototype.propertyIsEnumerable;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __spreadValues = (a, b) => {
for (var prop in b || (b = {}))
if (__hasOwnProp.call(b, prop))
__defNormalProp(a, prop, b[prop]);
if (__getOwnPropSymbols)
for (var prop of __getOwnPropSymbols(b)) {
if (__propIsEnum.call(b, prop))
__defNormalProp(a, prop, b[prop]);
}
return a;
};
var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
var __async = (__this, __arguments, generator) => {
return new Promise((resolve, reject) => {
var fulfilled = (value) => {
try {
step(generator.next(value));
} catch (e) {
reject(e);
}
};
var rejected = (value) => {
try {
step(generator.throw(value));
} catch (e) {
reject(e);
}
};
var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
step((generator = generator.apply(__this, __arguments)).next());
});
};
// src/stores/address.store.ts
import { create as create2 } from "zustand";
// src/stores/buzzebeess-app.store.ts
import { create } from "zustand";
var useBuzzebeesAppStore = create((set) => ({
appId: "",
appName: "",
bzbsService: null,
uuid: "",
macAddress: "",
clientVersion: "",
os: "",
platform: "",
fcmToken: "",
deviceNotificationEnabled: false,
urls: {
webCallback: "",
cart: ""
},
tokenFunctions: null,
tokenType: "jwt",
config: {
defaultDashboardConfig: "",
defaultDashboardMode: "main",
defaultMenuConfig: "",
defaultCampaignConfig: "",
supportPointUnits: []
},
setAppId: (appId) => set({ appId }),
setAppName: (appName) => set({ appName }),
setBzbsService: (service) => set({ bzbsService: service }),
setUuid: (uuid) => set({ uuid }),
setMacAddress: (macAddress) => set({ macAddress }),
setClientVersion: (clientVersion) => set({ clientVersion }),
setOs: (os) => set({ os }),
setPlatform: (platform) => set({ platform }),
setFcmToken: (fcmToken) => set({ fcmToken }),
setDeviceNotificationEnabled: (deviceNotificationEnabled) => set({ deviceNotificationEnabled }),
setUrls: (urls) => set({ urls }),
setTokenFunctions: (tokenFunctions) => set({ tokenFunctions }),
setTokenType: (tokenType) => set({ tokenType }),
configure: (config) => {
set({
appId: config.appId,
appName: config.appName,
bzbsService: config.bzbsService,
uuid: config.uuid,
macAddress: config.macAddress,
clientVersion: config.clientVersion,
os: config.os,
platform: config.platform,
fcmToken: config.fcmToken,
deviceNotificationEnabled: config.deviceNotificationEnabled,
urls: config.urls,
tokenFunctions: config.tokenFunctions,
tokenType: config.tokenType,
config: {
defaultDashboardConfig: config.defaultDashboardConfig,
defaultDashboardMode: config.defaultDashboardMode,
defaultMenuConfig: config.defaultMenuConfig,
defaultCampaignConfig: config.defaultCampaignConfig,
supportPointUnits: config.supportPointUnits
}
});
}
}));
// src/stores/address.store.ts
var useAddressStore = create2((set, get) => ({
addresses: [],
taxAddresses: [],
selectedAddress: null,
selectedTaxAddress: null,
isLoading: false,
error: null,
setSelectedAddress: (address) => set({ selectedAddress: address }),
fetchAddresses: () => __async(null, null, function* () {
const bzbsService = useBuzzebeesAppStore.getState().bzbsService;
if (!bzbsService) {
return { type: "client-error", message: "Service not configured" };
}
set({ isLoading: true });
const response = yield bzbsService.addressApi.userAddresses();
set({ isLoading: false });
if (response.type === "success") {
set({
addresses: response.model,
error: null
});
} else {
set({ error: response });
}
return response;
}),
addAddress: (addressForm) => __async(null, null, function* () {
const bzbsService = useBuzzebeesAppStore.getState().bzbsService;
if (!bzbsService) {
return { type: "client-error", message: "Service not configured" };
}
set({ isLoading: true });
const response = yield bzbsService.addressApi.updateAddress(__spreadProps(__spreadValues({}, addressForm), {
rowKey: ""
}));
set({ isLoading: false });
if (response.type === "success") {
get().fetchAddresses();
set({ error: null });
} else {
set({ error: response });
}
return response;
}),
editAddress: (addressForm) => __async(null, null, function* () {
const bzbsService = useBuzzebeesAppStore.getState().bzbsService;
if (!bzbsService) {
return { type: "client-error", message: "Service not configured" };
}
set({ isLoading: true });
const response = yield bzbsService.addressApi.updateAddress(__spreadValues({}, addressForm));
set({ isLoading: false });
if (response.type === "success") {
get().fetchAddresses();
set({ error: null });
} else {
set({ error: response });
}
return response;
}),
deleteAddress: (rowKey) => __async(null, null, function* () {
const bzbsService = useBuzzebeesAppStore.getState().bzbsService;
if (!bzbsService) {
return { type: "client-error", message: "Service not configured" };
}
set({ isLoading: true });
const response = yield bzbsService.addressApi.deleteAddress({ rowKey });
set({ isLoading: false });
if (response.type === "success") {
get().fetchAddresses();
set({ error: null });
} else {
set({ error: response });
}
return response;
}),
setSelectedTaxAddress: (address) => set({ selectedTaxAddress: address }),
fetchTaxAddresses: () => __async(null, null, function* () {
const bzbsService = useBuzzebeesAppStore.getState().bzbsService;
if (!bzbsService) {
return { type: "client-error", message: "Service not configured" };
}
set({ isLoading: true });
const response = yield bzbsService.addressApi.userTaxAddresses();
set({ isLoading: false });
if (response.type === "success") {
set({
taxAddresses: response.model,
error: null
});
} else {
set({ error: response });
}
return response;
}),
addTaxAddress: (addressForm) => __async(null, null, function* () {
const bzbsService = useBuzzebeesAppStore.getState().bzbsService;
if (!bzbsService) {
return { type: "client-error", message: "Service not configured" };
}
set({ isLoading: true });
const response = yield bzbsService.addressApi.updateTaxAddress(__spreadProps(__spreadValues({}, addressForm), {
rowKey: ""
}));
set({ isLoading: false });
if (response.type === "success") {
get().fetchTaxAddresses();
set({ error: null });
} else {
set({ error: response });
}
return response;
}),
editTaxAddress: (addressForm) => __async(null, null, function* () {
const bzbsService = useBuzzebeesAppStore.getState().bzbsService;
if (!bzbsService) {
return { type: "client-error", message: "Service not configured" };
}
set({ isLoading: true });
const response = yield bzbsService.addressApi.updateTaxAddress(__spreadProps(__spreadValues({}, addressForm), {
rowKey: addressForm.rowKey || ""
}));
set({ isLoading: false });
if (response.type === "success") {
get().fetchTaxAddresses();
set({ error: null });
} else {
set({ error: response });
}
return response;
}),
deleteTaxAddress: (rowKey) => __async(null, null, function* () {
const bzbsService = useBuzzebeesAppStore.getState().bzbsService;
if (!bzbsService) {
return { type: "client-error", message: "Service not configured" };
}
set({ isLoading: true });
const response = yield bzbsService.addressApi.deleteTaxAddress({ rowKey });
set({ isLoading: false });
if (response.type === "success") {
get().fetchTaxAddresses();
set({ error: null });
} else {
set({ error: response });
}
return response;
}),
clear: () => {
set({
addresses: [],
taxAddresses: [],
selectedAddress: null,
selectedTaxAddress: null,
isLoading: false,
error: null
});
}
}));
// src/stores/alert.store.ts
import { create as create3 } from "zustand";
var useAlertStore = create3((set, get) => ({
isOpen: false,
alertRequest: {
title: "",
content: "",
onClose: () => {
}
},
openAlert: (request) => {
set({ alertRequest: request, isOpen: true });
},
closeAlert: () => {
const { alertRequest } = get();
alertRequest.onClose();
set({ isOpen: false });
}
}));
// src/stores/analytics.store.ts
import MatomoTracker from "matomo-tracker-react-native";
import { create as create4 } from "zustand";
var useAnalyticsStore = create4((set, get) => ({
isInitialized: false,
isEnabled: true,
siteId: void 0,
urlBase: void 0,
trackerUrl: void 0,
userId: void 0,
disabled: false,
log: false,
matomoInstance: void 0,
presetUserInfo: void 0,
initialize: (config) => {
try {
const matomoInstance = new MatomoTracker({
urlBase: config.urlBase,
siteId: config.siteId,
trackerUrl: config.trackerUrl,
userId: config.userId,
disabled: config.disabled || false,
log: config.log || false
});
set({
siteId: config.siteId,
urlBase: config.urlBase,
trackerUrl: config.trackerUrl,
userId: config.userId,
disabled: config.disabled || false,
log: config.log || false,
matomoInstance,
isInitialized: true
});
console.log("Analytics: Matomo tracker initialized", config);
} catch (error) {
console.error("Analytics: Failed to initialize Matomo tracker", error);
set({
siteId: config.siteId,
urlBase: config.urlBase,
trackerUrl: config.trackerUrl,
userId: config.userId,
disabled: config.disabled || false,
log: config.log || false,
isInitialized: false
});
}
},
setEnabled: (enabled) => {
set({ isEnabled: enabled });
},
setPresetUserInfo: (userInfo) => {
set({ presetUserInfo: userInfo });
},
clearPresetUserInfo: () => {
set({ presetUserInfo: void 0 });
},
trackAppStart: (userInfo) => __async(null, null, function* () {
const state = get();
if (!state.isInitialized || !state.isEnabled || !state.matomoInstance || state.disabled) {
console.debug("Analytics: Track App Start skipped - not initialized, disabled, or tracking disabled");
return;
}
try {
const mergedUserInfo = __spreadValues(__spreadValues({}, state.presetUserInfo), userInfo);
yield state.matomoInstance.trackAppStart({
userInfo: Object.keys(mergedUserInfo).length > 0 ? mergedUserInfo : void 0
});
if (state.log) {
console.debug("Analytics: App start tracked successfully", { userInfo: mergedUserInfo });
}
} catch (error) {
console.error("Analytics: Failed to track app start", error);
}
}),
trackEvent: (params) => __async(null, null, function* () {
const state = get();
if (!state.isInitialized || !state.isEnabled || !state.matomoInstance || state.disabled) {
console.debug("Analytics: Track Event skipped - not initialized, disabled, or tracking disabled", params);
return;
}
try {
const mergedUserInfo = __spreadValues(__spreadValues({}, state.presetUserInfo), params.userInfo);
yield state.matomoInstance.trackEvent({
category: params.category || "User Action",
action: params.action,
name: params.name,
value: params.value,
campaign: params.campaign,
userInfo: Object.keys(mergedUserInfo).length > 0 ? mergedUserInfo : void 0
});
if (state.log) {
console.debug("Analytics: Event tracked successfully", params);
}
} catch (error) {
console.error("Analytics: Failed to track event", error, params);
}
}),
trackScreenView: (params) => __async(null, null, function* () {
const state = get();
if (!state.isInitialized || !state.isEnabled || !state.matomoInstance || state.disabled) {
console.debug("Analytics: Track Screen View skipped - not initialized, disabled, or tracking disabled", params);
return;
}
try {
const mergedUserInfo = __spreadValues(__spreadValues({}, state.presetUserInfo), params.userInfo);
yield state.matomoInstance.trackScreenView({
name: params.name,
userInfo: Object.keys(mergedUserInfo).length > 0 ? mergedUserInfo : void 0
});
if (state.log) {
console.debug("Analytics: Screen view tracked successfully", params);
}
} catch (error) {
console.error("Analytics: Failed to track screen view", error, params);
}
}),
trackAction: (params) => __async(null, null, function* () {
const state = get();
if (!state.isInitialized || !state.isEnabled || !state.matomoInstance || state.disabled) {
console.debug("Analytics: Track Action skipped - not initialized, disabled, or tracking disabled", params);
return;
}
try {
const mergedUserInfo = __spreadValues(__spreadValues({}, state.presetUserInfo), params.userInfo);
yield state.matomoInstance.trackAction({
name: params.name,
userInfo: Object.keys(mergedUserInfo).length > 0 ? mergedUserInfo : void 0
});
if (state.log) {
console.debug("Analytics: Action tracked successfully", params);
}
} catch (error) {
console.error("Analytics: Failed to track action", error, params);
}
}),
trackSiteSearch: (params) => __async(null, null, function* () {
const state = get();
if (!state.isInitialized || !state.isEnabled || !state.matomoInstance || state.disabled) {
console.debug("Analytics: Track Site Search skipped - not initialized, disabled, or tracking disabled", params);
return;
}
try {
const mergedUserInfo = __spreadValues(__spreadValues({}, state.presetUserInfo), params.userInfo);
yield state.matomoInstance.trackSiteSearch({
keyword: params.keyword,
category: params.category,
count: params.count,
userInfo: Object.keys(mergedUserInfo).length > 0 ? mergedUserInfo : void 0
});
if (state.log) {
console.debug("Analytics: Site search tracked successfully", params);
}
} catch (error) {
console.error("Analytics: Failed to track site search", error, params);
}
}),
trackLink: (params) => __async(null, null, function* () {
const state = get();
if (!state.isInitialized || !state.isEnabled || !state.matomoInstance || state.disabled) {
console.debug("Analytics: Track Link skipped - not initialized, disabled, or tracking disabled", params);
return;
}
try {
const mergedUserInfo = __spreadValues(__spreadValues({}, state.presetUserInfo), params.userInfo);
yield state.matomoInstance.trackLink({
link: params.link,
userInfo: Object.keys(mergedUserInfo).length > 0 ? mergedUserInfo : void 0
});
if (state.log) {
console.debug("Analytics: Link tracked successfully", params);
}
} catch (error) {
console.error("Analytics: Failed to track link", error, params);
}
}),
trackDownload: (params) => __async(null, null, function* () {
const state = get();
if (!state.isInitialized || !state.isEnabled || !state.matomoInstance || state.disabled) {
console.debug("Analytics: Track Download skipped - not initialized, disabled, or tracking disabled", params);
return;
}
try {
const mergedUserInfo = __spreadValues(__spreadValues({}, state.presetUserInfo), params.userInfo);
yield state.matomoInstance.trackDownload({
download: params.download,
userInfo: Object.keys(mergedUserInfo).length > 0 ? mergedUserInfo : void 0
});
if (state.log) {
console.debug("Analytics: Download tracked successfully", params);
}
} catch (error) {
console.error("Analytics: Failed to track download", error, params);
}
}),
setUserId: (userId) => {
const state = get();
if (userId) {
const updatedUserInfo = __spreadProps(__spreadValues({}, state.presetUserInfo), {
uid: userId
});
set({
userId,
presetUserInfo: updatedUserInfo
});
} else {
const currentUserInfo = state.presetUserInfo || {};
if (currentUserInfo.uid) {
const updatedUserInfo = __spreadValues({}, currentUserInfo);
delete updatedUserInfo.uid;
set({
userId: void 0,
presetUserInfo: Object.keys(updatedUserInfo).length > 0 ? updatedUserInfo : void 0
});
} else {
set({ userId: void 0 });
}
}
if (state.log) {
console.debug("Analytics: User ID updated in preset userInfo", userId);
}
},
setCustomDimension: (id, value) => {
const state = get();
if (!state.presetUserInfo) {
set({ presetUserInfo: { [`dimension${id}`]: value } });
} else {
set({
presetUserInfo: __spreadProps(__spreadValues({}, state.presetUserInfo), {
[`dimension${id}`]: value
})
});
}
if (state.log) {
console.debug("Analytics: Custom dimension set in preset userInfo", { id, value });
}
},
reset: () => {
set({
isInitialized: false,
isEnabled: true,
siteId: void 0,
urlBase: void 0,
trackerUrl: void 0,
userId: void 0,
disabled: false,
log: false,
matomoInstance: void 0,
presetUserInfo: void 0
});
console.debug("Analytics: Store reset successfully");
}
}));
// src/stores/auth.store.ts
import { create as create7 } from "zustand";
// src/utils/analytics.ts
var useAnalyticsState = () => {
return useAnalyticsStore();
};
var trackCommonEvents = {
/**
* Track register success event
* Screen: register, Category: register, Event: register_success
*/
registerSuccess: (userInfo) => __async(null, null, function* () {
const store = useAnalyticsStore.getState();
if (store.isInitialized && store.isEnabled) {
yield store.trackEvent({
action: "on click",
category: "register",
name: "register_success",
userInfo
});
}
}),
/**
* Track login success event
* Screen: login, Category: login, Event: login_success
*/
loginSuccess: (userInfo) => __async(null, null, function* () {
const store = useAnalyticsStore.getState();
if (store.isInitialized && store.isEnabled) {
yield store.trackEvent({
action: "on click",
category: "login",
name: "login_success",
userInfo
});
}
}),
/**
* Track view campaign event
* Screen: campaign, Category: campaign_list, Event: view_campaign
*/
viewCampaign: (userInfo) => __async(null, null, function* () {
const store = useAnalyticsStore.getState();
if (store.isInitialized && store.isEnabled) {
yield store.trackEvent({
action: "on click",
category: "campaign_list",
name: "view_campaign",
userInfo
});
}
}),
/**
* Track redeem success event
* Screen: campaign, Category: campaign_redeem, Event: redeem_success
*/
redeemSuccess: (campaignId, userInfo) => __async(null, null, function* () {
const store = useAnalyticsStore.getState();
if (store.isInitialized && store.isEnabled) {
yield store.trackEvent({
action: "on click",
category: "campaign_redeem",
name: "redeem_success",
// Use campaign_id as label - can be passed in userInfo or as a separate dimension
userInfo: __spreadProps(__spreadValues({}, userInfo), {
dimension3: campaignId
// Store campaign_id in dimension3
})
});
}
}),
/**
* Track unconsent success event
* Screen: marketing, Category: marketing_unconsent, Event: unconsent_success
*/
unconsentSuccess: (userInfo) => __async(null, null, function* () {
const store = useAnalyticsStore.getState();
if (store.isInitialized && store.isEnabled) {
yield store.trackEvent({
action: "on click",
category: "marketing_unconsent",
name: "unconsent_success",
userInfo
});
}
}),
/**
* Track button click event
*/
buttonClick: (buttonName, category = "UI", userInfo) => __async(null, null, function* () {
const store = useAnalyticsStore.getState();
if (store.isInitialized && store.isEnabled) {
yield store.trackEvent({
action: "on click",
category,
name: buttonName,
userInfo
});
}
}),
/**
* Track form submit event
*/
formSubmit: (formName, success = true, userInfo) => __async(null, null, function* () {
const store = useAnalyticsStore.getState();
if (store.isInitialized && store.isEnabled) {
yield store.trackEvent({
action: "submit",
category: "Form",
name: formName,
userInfo: __spreadProps(__spreadValues({}, userInfo), {
dimension1: success ? "success" : "failure"
})
});
}
}),
/**
* Track search event
*/
search: (keyword, resultCount, category = "Search", userInfo) => __async(null, null, function* () {
const store = useAnalyticsStore.getState();
if (store.isInitialized && store.isEnabled) {
yield store.trackSiteSearch({
keyword,
category,
count: resultCount,
userInfo
});
}
}),
/**
* Track purchase event
*/
purchase: (amount, currency = "THB", productName, userInfo) => __async(null, null, function* () {
const store = useAnalyticsStore.getState();
if (store.isInitialized && store.isEnabled) {
yield store.trackEvent({
action: "purchase",
category: "Commerce",
name: productName || "Purchase",
value: amount,
userInfo: __spreadProps(__spreadValues({}, userInfo), {
dimension1: currency
})
});
}
}),
/**
* Track user registration event
*/
userRegistration: (method = "email", userInfo) => __async(null, null, function* () {
const store = useAnalyticsStore.getState();
if (store.isInitialized && store.isEnabled) {
yield store.trackEvent({
action: "register",
category: "User",
name: `registration_${method}`,
userInfo
});
}
}),
/**
* Track user login event
*/
userLogin: (method = "email", userInfo) => __async(null, null, function* () {
const store = useAnalyticsStore.getState();
if (store.isInitialized && store.isEnabled) {
yield store.trackEvent({
action: "login",
category: "User",
name: `login_${method}`,
userInfo
});
}
}),
/**
* Track error event
*/
error: (errorType, errorMessage, userInfo) => __async(null, null, function* () {
const store = useAnalyticsStore.getState();
if (store.isInitialized && store.isEnabled) {
yield store.trackEvent({
action: "error",
category: "Error",
name: errorType,
userInfo: __spreadProps(__spreadValues({}, userInfo), {
dimension2: errorMessage
})
});
}
}),
/**
* Track custom event
*/
custom: (name, category, label, value, userInfo) => __async(null, null, function* () {
const store = useAnalyticsStore.getState();
if (store.isInitialized && store.isEnabled) {
yield store.trackEvent({
action: "custom",
category,
name,
value,
userInfo: __spreadProps(__spreadValues({}, userInfo), {
dimension1: label
})
});
}
})
};
var initializeAnalytics = (config) => {
const store = useAnalyticsStore.getState();
store.initialize(config);
};
var analytics = {
/**
* Initialize analytics (can be called outside React components)
*/
init: (config) => {
const store = useAnalyticsStore.getState();
store.initialize(config);
},
/**
* Track event (can be called outside React components)
*/
trackEvent: (params) => __async(null, null, function* () {
const store = useAnalyticsStore.getState();
if (store.isInitialized && store.isEnabled) {
yield store.trackEvent(params);
}
}),
/**
* Track screen view (can be called outside React components)
*/
trackScreenView: (name, userInfo) => __async(null, null, function* () {
const store = useAnalyticsStore.getState();
if (store.isInitialized && store.isEnabled) {
yield store.trackScreenView({ name, userInfo });
}
}),
/**
* Track app start (can be called outside React components)
*/
trackAppStart: (userInfo) => __async(null, null, function* () {
const store = useAnalyticsStore.getState();
if (store.isInitialized && store.isEnabled) {
yield store.trackAppStart(userInfo);
}
}),
/**
* Track site search (can be called outside React components)
*/
trackSiteSearch: (keyword, category, count, userInfo) => __async(null, null, function* () {
const store = useAnalyticsStore.getState();
if (store.isInitialized && store.isEnabled) {
yield store.trackSiteSearch({ keyword, category, count, userInfo });
}
}),
/**
* Track link click (can be called outside React components)
*/
trackLink: (link, userInfo) => __async(null, null, function* () {
const store = useAnalyticsStore.getState();
if (store.isInitialized && store.isEnabled) {
yield store.trackLink({ link, userInfo });
}
}),
/**
* Track download (can be called outside React components)
*/
trackDownload: (download, userInfo) => __async(null, null, function* () {
const store = useAnalyticsStore.getState();
if (store.isInitialized && store.isEnabled) {
yield store.trackDownload({ download, userInfo });
}
}),
/**
* Set user ID and update preset userInfo (can be called outside React components)
*/
setUserId: (userId) => {
const store = useAnalyticsStore.getState();
store.setUserId(userId);
},
/**
* Set custom dimension (can be called outside React components)
*/
setCustomDimension: (id, value) => {
const store = useAnalyticsStore.getState();
store.setCustomDimension(id, value);
},
/**
* Set preset user info (can be called outside React components)
*/
setPresetUserInfo: (userInfo) => {
const store = useAnalyticsStore.getState();
store.setPresetUserInfo(userInfo);
},
/**
* Clear preset user info (can be called outside React components)
*/
clearPresetUserInfo: () => {
const store = useAnalyticsStore.getState();
store.clearPresetUserInfo();
},
/**
* Enable/disable analytics (can be called outside React components)
*/
setEnabled: (enabled) => {
const store = useAnalyticsStore.getState();
store.setEnabled(enabled);
},
/**
* Reset analytics (can be called outside React components)
*/
reset: () => {
const store = useAnalyticsStore.getState();
store.reset();
}
};
// src/utils/string_utils.ts
function isValidEmail(email) {
return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email);
}
// src/constant.tsx
var campaignType = {
draw: 0,
free: 1,
deal: 2,
buy: 3,
bid: 4,
ads: 5,
install: 6,
booking: 7,
interface: 8,
event: 9,
media: 10,
ewalletTopUp: 11,
ewalletRedeem: 12,
ewalletTransfer: 13,
ewalletBanking: 14,
autofeed: 15,
news: 16,
reservation: 17,
ewalletBuy: 18,
pointRedemption: 19,
donate: 20,
pointFree: 21,
voucher: 22,
encrypt: 23,
encryptRedeem: 24,
giftCard: 25,
verifyCode: 26,
subscription: 27,
fillCode: 28,
subscriptionFood: 29,
buyEVoucher: 30,
uploadReceipt: 31,
payWithPoints: 32,
marketPlacePrivilege: 33,
topup2C2P: 34,
directTopup2C2P: 35
};
var campaignPointType = {
use: "use",
get: "get"
};
var campaignInterfaceType = {
web: "web",
survey: "survey",
surveyApprove: "surveyapprove"
};
// src/utils/purchase_utils.ts
function getPurchaseItemStatus(item) {
var _a, _b, _c, _d;
const title = (_a = item.Name) != null ? _a : "";
const pointPerUnit = (_b = item.PointPerUnit) != null ? _b : 0;
const image = (_c = item.FullImageUrl) != null ? _c : "";
const expireDate = new Date(((_d = item.VoucherExpireDate) != null ? _d : 0) * 1e3);
let showCode = true;
let status = "redeemed";
let drawStatus = null;
if (item.Type === campaignType.draw) {
showCode = false;
if (item.HasWinner) {
drawStatus = item.IsWinner ? "draw_win" : "draw_lose";
} else {
drawStatus = "draw_waiting";
}
}
let deliveryStatus = null;
if (item.Delivered) {
if (item.IsShipped === false && (item.ParcelNo === null || item.ParcelNo === void 0 || item.ParcelNo === "")) {
deliveryStatus = "packing";
} else if (item.IsShipped === false) {
deliveryStatus = "shipping";
} else {
deliveryStatus = "shipped";
}
}
if (item.ArrangedDate) {
return { title, pointPerUnit, expireDate, image, showCode: false, expired: false, status: "used", deliveryStatus, drawStatus };
}
if (item.IsExpired || item.ExpireIn && item.ExpireIn <= 0) {
return { title, pointPerUnit, expireDate, image, showCode: false, expired: true, status: "expired", deliveryStatus, drawStatus };
}
if (item.VoucherExpireDate && item.VoucherExpireDate <= Date.now() / 1e3) {
return { title, pointPerUnit, expireDate, image, showCode: false, expired: true, status: "expired", deliveryStatus, drawStatus };
}
switch (item.Type) {
case campaignType.free:
case campaignType.deal:
status = "redeemed";
showCode = true;
break;
}
return {
title,
pointPerUnit,
expireDate,
image,
showCode,
expired: false,
status,
deliveryStatus,
drawStatus
};
}
// src/utils/locale.ts
var localeToLCIDMap = {
"ar-SA": 1025,
"bg-BG": 1026,
"ca-ES": 1027,
"zh-TW": 1028,
"cs-CZ": 1029,
"da-DK": 1030,
"de-DE": 1031,
"el-GR": 1032,
"en-US": 1033,
"es-ES": 1034,
"fi-FI": 1035,
"fr-FR": 1036,
"he-IL": 1037,
"hu-HU": 1038,
"is-IS": 1039,
"it-IT": 1040,
"ja-JP": 1041,
"ko-KR": 1042,
"nl-NL": 1043,
"nb-NO": 1044,
"pl-PL": 1045,
"pt-BR": 1046,
"rm-CH": 1047,
"ro-RO": 1048,
"ru-RU": 1049,
"hr-HR": 1050,
"sk-SK": 1051,
"sq-AL": 1052,
"sv-SE": 1053,
"th-TH": 1054,
"tr-TR": 1055,
"ur-PK": 1056,
"id-ID": 1057,
"uk-UA": 1058,
"be-BY": 1059,
"sl-SI": 1060,
"et-EE": 1061,
"lv-LV": 1062,
"lt-LT": 1063,
"tg-Cyrl-TJ": 1064,
"fa-IR": 1065,
"vi-VN": 1066,
"hy-AM": 1067,
"az-Latn-AZ": 1068,
"eu-ES": 1069,
"wen-DE": 1070,
"mk-MK": 1071,
"st-ZA": 1072,
"ts-ZA": 1073,
"tn-ZA": 1074,
"ven-ZA": 1075,
"xh-ZA": 1076,
"zu-ZA": 1077,
"af-ZA": 1078,
"ka-GE": 1079,
"fo-FO": 1080,
"hi-IN": 1081,
"mt-MT": 1082,
"se-NO": 1083,
"gd-GB": 1084,
yi: 1085,
"ms-MY": 1086,
"kk-KZ": 1087,
"ky-KG": 1088,
"sw-KE": 1089,
"tk-TM": 1090,
"uz-Latn-UZ": 1091,
"tt-RU": 1092,
"bn-IN": 1093,
"pa-IN": 1094,
"gu-IN": 1095,
"or-IN": 1096,
"ta-IN": 1097,
"te-IN": 1098,
"kn-IN": 1099,
"ml-IN": 1100,
"as-IN": 1101,
"mr-IN": 1102,
"sa-IN": 1103,
"mn-MN": 1104,
"bo-CN": 1105,
"cy-GB": 1106,
"km-KH": 1107,
"lo-LA": 1108,
"my-MM": 1109,
"gl-ES": 1110,
"kok-IN": 1111,
mni: 1112,
"sd-IN": 1113,
"syr-SY": 1114,
"si-LK": 1115,
"chr-US": 1116,
"iu-Cans-CA": 1117,
"am-ET": 1118,
tmz: 1119,
"ks-Arab-IN": 1120,
"ne-NP": 1121,
"fy-NL": 1122,
"ps-AF": 1123,
"fil-PH": 1124,
"dv-MV": 1125,
"bin-NG": 1126,
"fuv-NG": 1127,
"ha-Latn-NG": 1128,
"ibb-NG": 1129,
"yo-NG": 1130,
"quz-BO": 1131,
"nso-ZA": 1132,
"ig-NG": 1136,
"kr-NG": 1137,
"gaz-ET": 1138,
"ti-ER": 1139,
"gn-PY": 1140,
"haw-US": 1141,
la: 1142,
"so-SO": 1143,
"ii-CN": 1144,
"pap-AN": 1145,
"ug-Arab-CN": 1152,
"mi-NZ": 1153,
"ar-IQ": 2049,
"zh-CN": 2052,
"de-CH": 2055,
"en-GB": 2057,
"es-MX": 2058,
"fr-BE": 2060,
"it-CH": 2064,
"nl-BE": 2067,
"nn-NO": 2068,
"pt-PT": 2070,
"ro-MD": 2072,
"ru-MD": 2073,
"sr-Latn-CS": 2074,
"sv-FI": 2077,
"ur-IN": 2080,
"az-Cyrl-AZ": 2092,
"ga-IE": 2108,
"ms-BN": 2110,
"uz-Cyrl-UZ": 2115,
"bn-BD": 2117,
"pa-PK": 2118,
"mn-Mong-CN": 2128,
"bo-BT": 2129,
"sd-PK": 2137,
"tzm-Latn-DZ": 2143,
"ks-Deva-IN": 2144,
"ne-IN": 2145,
"quz-EC": 2155,
"ti-ET": 2163,
"ar-EG": 3073,
"zh-HK": 3076,
"de-AT": 3079,
"en-AU": 3081,
"fr-CA": 3084,
"sr-Cyrl-CS": 3098,
"ar-LY": 4097,
"zh-SG": 4100,
"de-LU": 4103,
"en-CA": 4105,
"fr-CH": 4108,
"hr-BA": 4122,
"ar-DZ": 5121,
"zh-MO": 5124,
"de-LI": 5127,
"en-NZ": 5129,
"fr-LU": 5132,
"bs-Latn-BA": 5146,
"ar-MO": 6145,
"fr-MC": 6156,
"ar-TN": 7169,
"ar-OM": 8193,
"ar-YE": 9217,
"en-BZ": 10249,
"es-PE": 10250,
"fr-SN": 10252,
"ar-JO": 11265,
"fr-CM": 11276,
"en-ID": 14345,
"es-CL": 13322,
"en-HK": 15369,
"fr-MA": 14348,
"en-MY": 17417,
"es-SV": 17418,
"es-NI": 19466,
"es-PR": 20490,
"es-US": 21514,
"fr-015": 58380
};
function findBestLocaleFromString(value) {
if (localeToLCIDMap[value]) {
return {
locale: value,
localeId: localeToLCIDMap[value]
};
}
const partialMatch = Object.keys(localeToLCIDMap).find((key) => key.startsWith(value.split("-")[0]));
if (partialMatch) {
return {
locale: partialMatch,
localeId: localeToLCIDMap[partialMatch]
};
}
throw new Error(`Locale '${value}' is not supported.`);
}
// src/stores/locale.store.ts
import { create as create5 } from "zustand";
var EN = { locale: "en", localeId: 1033 };
var TH = { locale: "th", localeId: 1054 };
var useLocaleStore = create5((set) => ({
appLocale: EN,
locale: "en",
localeId: 1033,
setAppLocale: (locale) => {
const newLocale = typeof locale === "string" ? findBestLocaleFromString(locale) : locale;
set({
appLocale: newLocale,
locale: newLocale.locale,
localeId: newLocale.localeId
});
}
}));
// src/stores/user.store.ts
import { create as create6 } from "zustand";
// src/service/bzbs_service.ts
import * as blake from "blakejs";
import Emittery from "emittery";
import { v7 as uuidv7 } from "uuid";
var eventEmitter = new Emittery();
function defaultCorelationIdGenerator() {
return uuidv7();
}
function isJWT(token) {
return typeof token === "string" && token.split(".").length === 3;
}
function addDefaultHeaderInterceptor(axiosInstance, appId, subscriptionKey, tokenFunctions, apiVersion, corelationIdGenerator = defaultCorelationIdGenerator) {
axiosInstance.interceptors.request.use(
(config) => __async(null, null, function* () {
config.headers.set("App-Id", appId);
if (subscriptionKey) {
config.headers.set("Subscription-Key", subscriptionKey);
}
if (apiVersion) {
config.headers.set("Api-Version", apiVersion);
}
config.headers.set("X-Corelation-Id", corelationIdGenerator());
const token = yield tokenFunctions.getToken();
if (token) {
if (isJWT(token)) {
config.headers.set("Authorization", `Bearer ${token}`);
} else {
config.headers.set("Authorization", `token ${token}`);
}
}
return config;
}),
(error) => {
return Promise.reject(error);
}
);
axiosInstance.interceptors.response.use(
(response) => {
const responseData = response.data;
let responseModel;
let responseError;
const hasSuccessField = "Success" in responseData || "success" in responseData;
if (hasSuccessField) {
if (responseData.Success === false || responseData.success === false) {
responseError = {
code: String(responseData.Code || responseData.code || ""),
id: String(responseData.Code || responseData.code || ""),
message: String(responseData.Message || responseData.message || "")
};
}
responseModel = responseData.Data || responseData.data;
} else {
if (responseData.error) {
responseError = {
code: String(responseData.error.code),
id: String(responseData.error.id),
message: String(responseData.error.message)
};
} else {
responseModel = responseData;
}
}
const buzzebeesObj = responseModel == null ? void 0 : responseModel.buzzebees;
if (buzzebeesObj) {
if (typeof buzzebeesObj.points === "number") {
eventEmitter.emit("get_points", buzzebeesObj);
}
if (buzzebeesObj.badges) {
eventEmitter.emit("get_badges", buzzebeesObj.badges);
}
}
if (responseError) {
const { id, code } = responseError;
if (code === "1905" || code === "2076" || id === "1905" || id === "2076") {
eventEmitter.emit("session_expired", responseError);
}
}
return response;
},
(error) => {
return Promise.reject(error);
}
);
}
function generateShortLivedId() {
return Math.random().toString(36).substring(2, 15);
}
function avatarUrl(baseUrl, appId, userId, token) {
const url = `${baseUrl}/profile/${userId}/picture?timestamp=${Date.now()}&type=large${token === null ? "" : `&token=${token}&device_app_id=${appId}`}`;
console.log(url);
return url;
}
function largeImage(url) {
if (!url) return "";
const result = url.replace("?", "-large?");
return result;
}
function fetchImage(axiosClient, imageUrl) {
return __async(this, null, function* () {
try {
const response = yield axiosClient.get(imageUrl, { responseType: "blob" });
return response.data;
} catch (error) {
console.error("Error fetching image:", error);
}
});
}
function createInterfaceWebsiteUrl(url, token, returnUrl = "", params) {
if (token) {
params = __spreadValues({
token: createInterfaceToken(token),
return_url: returnUrl
}, params);
}
const searchParams = new URLSearchParams(params).toString();
const result = url.includes("?") ? `${url}&${searchParams}` : `${url}?${searchParams}`;
return result;
}
function createInterfaceToken(token) {
if (token.length <= 5) {
return token;
}
const firstChar = token.substring(0, 1);
const last5Chars = token.substring(token.length - 5);
const remainingChars = token.substring(1, token.length - 5);
return firstChar === "." ? `${last5Chars}${remainingChars}` : token;
}
function createCartUrl(cartUrl, appName, accessKey, params) {
const newUrl = cartUrl.endsWith("/") ? `${cartUrl}landing/${appName}` : `${cartUrl}/landing/${appName}`;
const newParams = __spreadValues({
access_key: accessKey,
appname_config: appName
}, params);
const searchParams = new URLSearchParams(newParams).toString();
return searchParams ? `${newUrl}?${searchParams}` : newUrl;
}
function generateBlake2bSignatureHex(data, key, encoder) {
const keyBytes = encoder.encode(key);
return blake.blake2bHex(data, keyBytes, 32);
}
function getOtpSignatureHeaders({
appId,
contactNumber,
channel,
encoder,
now = /* @__PURE__ */ new Date()
}) {
const dateTime = now.toISOString().split(".")[0] + "Z";
const timeStamp = Math.floor(now.getTime() / 1e3);
const data = `${appId}|${contactNumber}|${channel}|${dateTime}`;
const signature = generateBlake2bSignatureHex(data, appId, encoder);
return {
"OTP-Signature": signature,
Timestamp: timeStamp
};
}
function addBlake2OtpSignatureInterceptor(axiosInstance, paths, encoder, getCurrentDateTime = () => /* @__PURE__ */ new Date()) {
axiosInstance.interceptors.request.use((config) => {
if (paths.some((path) => config.url && config.url.includes(path))) {
const getParam = (key) => {
if (config.params && config.params[key]) return config.params[key];
if (config.data && typeof config.data === "object" && config.data[key]) return config.data[key];
return void 0;
};
const appId = getParam("app_id");
const contactNumber = getParam("contact_number");
const channel = getParam("channel");
if (appId && contactNumber && channel) {
const now = getCurrentDateTime();
const headers = getOtpSignatureHeaders({ appId, contactNumber, channel, now, encoder });
config.headers.set("OTP-Signature", headers["OTP-Signature"]);
config.headers.set("Timestamp", headers["Timestamp"]);
}
}
return config;
});
}
var getProfileImageSource = (baseUrl, appId, subscriptionKey, apiVersion, token, corelationIdGenerator = defaultCorelationIdGenerator, timestamp = Date.now(), type = "large") => {
const uri = `${baseUrl}/profile/picture?timestamp=${timestamp}&type=${type}`;
const headers = {
"Api-Version": apiVersion,
"Subscription-Key": subscriptionKey,
"App-Id": appId,
"X-Corelation-Id": corelationIdGenerator()
};
if (isJWT(token)) {
headers["Authorization"] = `Bearer ${token}`;
} else {
headers["Authorization"] = `token ${token}`;
}
return {
uri,
headers
};
};
// src/stores/user.store.ts
var useUserStore = create6((set, get) => {
return {
user: null,
points: 0,
pointServiceBalance: {},
expiringPointService: {},
recentPoints: 0,
expiringPoints: [],
recentBadge: null,
recentTrace: null,
cartCount: 0,
isLoading: false,
error: null,
imageError: null,
badgeList: [],
traceList: [],
thirdPartyConnection: {
facebook: false,
google: false,
apple: false,
line: false
},
fetchUser: () => __async(null, null, function* () {
var _a, _b, _c, _d, _e, _f, _g, _h;
set({ isLoading: true });
const bzbsService = useBuzzebeesAppStore.getState().bzbsService;
if (!bzbsService) {
set({ isLoading: false, error: { type: "client-error", message: "Service not configured" } });
return { type: "client-error", message: "Service not configured" };
}
const response = yield bzbsService.profileApi.profile();
set({ isLoading: false });
if (response.type === "success") {
const user = response.model;
set({
user,
error: null,
thirdPartyConnection: {
facebook: ((_a = user.Account) == null ? void 0 : _a.facebookId) != null && ((_b = user.Account) == null ? void 0 : _b.facebookId) !== "",
google: ((_c = user.Account) == null ? void 0 : _c.googleId) != null && ((_d = user.Account) == null ? void 0 : _d.googleId) !== "",
apple: ((_e = user.Account) == null ? void 0 : _e.appleId) != null && ((_f = user.Account) == null ? void 0 : _f.appleId) !== "",
line: ((_g = user.Account) == null ? void 0 : _g.lineUserId) != null && ((_h = user.Account) == null ? void 0 : _h.lineUserId) !== ""
}
});
} else {
set({ error: response });
}
return response;
}),
fetchPoint: () => __async(null, null, function* () {
var _a;
set({ isLoading: true });
const bzbsService = useBuzzebeesAppStore.getState().bzbsService;
if (!bzbsService) {
set({ isLoading: false, error: { type: "client-error", message: "Service not configured" } });
return {
pointResponse: { type: "client-error", message: "Service not configured" },
customPointsResponse: { type: "client-error", message: "Service not configured" }
};
}
const [pointResponse, customPointsResponse] = yield Promise.all([
bzbsService.profileApi.points(),
bzbsService.pointApi.detail()
]);
set({ isLoading: false });
if (pointResponse.type === "success") {
set({ points: (_a = pointResponse.model.points) != null ? _a : 0 });
}
if (customPointsResponse.type === "success") {
set({
pointServiceBalance: customPointsResponse.model.reduce(
(acc, curr) => {
acc[curr.Unit] = curr.Balance;
return acc;
},
{}
),
expiringPointService: customPointsResponse.model.reduce(
(acc, curr) => {
var _a2;
acc[curr.Unit] = Object.entries((_a2 = curr.Currents) != null ? _a2 : {}).map(([date, points]) => ({
date,
points
}));
return acc;
},
{}
)
});
}
return { pointResponse, customPointsResponse };
}),
fetchExpiringPoints: () => __async(null, null, function* () {
var _a;
set({ isLoading: true });
const bzbsService = useBuzzebeesAppStore.getState().bzbsService;
if (!bzbsService) {
set({ isLoading: false, error: { type: "client-error", message: "Service not configured" } });
return { type: "client-error", message: "Service not configured" };
}
const response = yield bzbsService.profileApi.expiringPoints();
set({ isLoading: false });
if (response.type === "success") {
set({ expiringPoints: (_a = response.model.expiring_points) != null ? _a : [], error: null });
} else {
set({ error: response });
}
return response;
}),
fetchCartCount: () => __async(null, null, function* () {
var _a;
set({ isLoading: true });
const bzbsService = useBuzzebeesAppStore.getState().bzbsService;
if (!bzbsService) {
set({ isLoading: false, error: { type: "client-error", message: "Service not configured" } });
return { type: "client-error", message: "Service not configured" };
}
const response = yield bzbsService.cartApi.cartCount({});
set({ isLoading: false });
if (response.type === "success") {
set({ cartCount: (_a = response.model.cart_count) != null ? _a : 0, error: null });
} else {
set({ error: response, cartCount: 0 });
}
return response;
}),
editUser: (data) => __async(null, null, function* () {
set({ isLoading: true });
const bzbsService = useBuzzebeesAppStore.getState().bzbsService;
if (!bzbsService) {
set({ isLoading: false, error: { type: "client-error", message: "Service not configured" } });
return { type: "client-error", message: "Service not configured" };
}
const response = yield bzbsService.profileApi.updateProfile(data);
if (data.profileImage) {
const imageResponse = yield bzbsService.profileApi.updateProfileImage({ image: data.profileImage });
if (imageResponse.type !== "success") {
set({ imageError: imageResponse });
}
}
set({ isLoading: false });
if (response.type === "success") {
set({ user: response.model, error: null });
const { tokenFunctions, tokenType } = useBuzzebeesAppStore.getState();
const token = tokenType === "jwt" ? response.model.Jwt : response.model.Token;
if (token && tokenFunctions) {
tokenFunctions.setToken(token);
}
} else {
set({ error: response });
}
return response;
}),
changePassword: (oldPassword, newPassword) => __async(null, null, function* () {
set({ isLoading: true });
const bzbsService = useBuzzebeesAppStore.getState().bzbsService;
if (!bzbsService) {
set({ isLoading: false, error: { type: "client-error", message: "Service not configured" } });
return { type: "client-error", message: "Service not configured" };
}
const response = yield bzbsService.profileApi.changePassword({ current: oldPassword, change: newPassword });
set({ isLoading: false });
if (response.type === "success") {
set({ error: null });
} else {
set({ error: response });
}
return response;
}),
changeContactNumber: (contactNumber, otp, refCode) => __async(null, null, function* () {
set({ isLoading: true });
const bzbsService = useBuzzebeesAppStore.getState().bzbsService;
if (!bzbsService) {
set({ isLoading: false, error: { type: "client-error", message: "Service not configured" } });
return { type: "client-error", message: "Service not configured" };
}
const response = yield bzbsService.profileApi.changeContactNumber({ contactNumber, otp, refCode });
set({ isLoading: false });
if (response.type === "success") {
set({ error: null });
} else {
set({ error: response });
}
return response;
}),
changeAvatar: (avatar) => __async(null, null, function* () {
set({ isLoading: true });
const bzbsService = useBuzzebeesAppStore.getState().bzbsService;
if (!bzbsService) {
set({ isLoading: false, error: { type: "client-error", message: "Service not configured" } });
return { type: "client-error", message: "Service not configured" };
}
const response = yield bzbsService.profileApi.updateProfileImage({ image: avatar });
set({ isLoading: false });
if (response.type === "success") {
set({ imageError: null });
} else {
set({ imageError: response });
}