repo
stringclasses 4
values | file_path
stringlengths 6
193
| extension
stringclasses 23
values | content
stringlengths 0
1.73M
| token_count
int64 0
724k
| __index_level_0__
int64 0
10.8k
|
|---|---|---|---|---|---|
hyperswitch-web
|
src/Window.res
|
.res
|
type window
type parent
type document
type style
type eventData = {
elementType: string,
clickTriggered: bool,
ready: bool,
focus: bool,
blur: bool,
confirmTriggered: bool,
oneClickConfirmTriggered: bool,
}
type loaderEvent = {key: string, data: eventData}
type event = {key: string, data: string, origin: string}
type date = {now: unit => string}
type body
type packageJson = {version: string}
/* External Declarations */
@val external window: window = "window"
@val @scope("window") external innerHeight: int = "innerHeight"
@val @scope("window") external innerWidth: int = "innerWidth"
@val @scope("window") external windowParent: window = "parent"
@val external parent: window = "parent"
@val @scope("document") external createElement: string => Dom.element = "createElement"
@val @scope("document") external querySelector: string => Nullable.t<Dom.element> = "querySelector"
@val @scope("document") external querySelectorAll: string => array<Dom.element> = "querySelectorAll"
@module("/package.json") @val external packageJson: packageJson = "default"
@val @scope("document") external body: body = "body"
@val @scope("window") external getHyper: Nullable.t<Types.hyperInstance> = "HyperMethod"
@val @scope("window") external addEventListener: (string, _ => unit) => unit = "addEventListener"
@val @scope("window")
external removeEventListener: (string, 'ev => unit) => unit = "removeEventListener"
@val @scope("window") external btoa: string => string = "btoa"
@new external date: date = "Date"
@get external value: Dom.element => 'a = "value"
/* External Methods */
@scope("window") @get external cardNumberElement: window => option<window> = "cardNumber"
@get external cardCVCElement: window => option<window> = "cardCvc"
@get external cardExpiryElement: window => option<window> = "cardExpiry"
@get external document: window => document = "document"
@get external fullscreen: window => option<window> = "fullscreen"
@get external frames: window => {..} = "frames"
@get external name: window => string = "name"
@get external contentWindow: Dom.element => Dom.element = "contentWindow"
@get external style: Dom.element => style = "style"
@send external getAttribute: (Dom.element, string) => Nullable.t<string> = "getAttribute"
@send external postMessage: (Dom.element, string, string) => unit = "postMessage"
@send external postMessageJSON: (Dom.element, JSON.t, string) => unit = "postMessage"
@send external getElementById: (document, string) => Nullable.t<Dom.element> = "getElementById"
@send external preventDefault: (event, unit) => unit = "preventDefault"
@send external appendChild: (body, Dom.element) => unit = "appendChild"
@send external remove: Dom.element => unit = "remove"
@send external setAttribute: (Dom.element, string, string) => unit = "setAttribute"
@send external paymentRequest: (JSON.t, JSON.t, JSON.t) => JSON.t = "PaymentRequest"
@send external click: Dom.element => unit = "click"
@set external innerHTML: (Dom.element, string) => unit = "innerHTML"
@set external className: (Dom.element, string) => unit = "className"
@set external id: (Dom.element, string) => unit = "id"
@set external elementSrc: (Dom.element, string) => unit = "src"
@set external elementOnload: (Dom.element, unit => unit) => unit = "onload"
@set external elementOnerror: (Dom.element, exn => unit) => unit = "onerror"
@set external setTransition: (style, string) => unit = "transition"
@set external setHeight: (style, string) => unit = "height"
@set external windowOnload: (window, unit => unit) => unit = "onload"
@set external setHyper: (window, Types.hyperInstance) => unit = "HyperMethod"
@send external closeWindow: window => unit = "close"
@val external windowOpen: (string, string, string) => Nullable.t<window> = "open"
/* Module Definitions */
module Navigator = {
@val @scope("navigator")
external browserName: string = "appName"
@val @scope("navigator")
external browserVersion: string = "appVersion"
@val @scope(("window", "navigator"))
external language: string = "language"
@val @scope(("window", "navigator"))
external platform: string = "platform"
@val @scope(("window", "navigator"))
external userAgent: string = "userAgent"
@val @scope("navigator")
external sendBeacon: (string, string) => unit = "sendBeacon"
}
module Location = {
@val @scope(("window", "location"))
external replace: string => unit = "replace"
@val @scope(("window", "location"))
external hostname: string = "hostname"
@val @scope(("window", "location"))
external href: string = "href"
@val @scope(("window", "location"))
external origin: string = "origin"
@val @scope(("window", "location"))
external protocol: string = "protocol"
@val @scope(("window", "location"))
external pathname: string = "pathname"
}
module Top = {
module Location = {
@val @scope(("window", "top", "location"))
external replace: string => unit = "replace"
@val @scope(("window", "top", "location"))
external hostname: string = "hostname"
@val @scope(("window", "top", "location"))
external href: string = "href"
@val @scope(("window", "top", "location"))
external origin: string = "origin"
@val @scope(("window", "top", "location"))
external protocol: string = "protocol"
@val @scope(("window", "top", "location"))
external pathname: string = "pathname"
}
}
module LocalStorage = {
@scope(("window", "localStorage")) @val external setItem: (string, string) => unit = "setItem"
@scope(("window", "localStorage")) @val external getItem: string => Nullable.t<string> = "getItem"
@scope(("window", "localStorage")) @val external removeItem: string => unit = "removeItem"
}
module Element = {
@get external clientWidth: Dom.element => int = "clientWidth"
}
/* Helper Functions */
let sendPostMessage = (element, message) => {
element->postMessage(message->JSON.Encode.object->JSON.stringify, GlobalVars.targetOrigin)
}
let sendPostMessageJSON = (element, message) => {
element->postMessageJSON(message, GlobalVars.targetOrigin)
}
let iframePostMessage = (iframeRef: nullable<Dom.element>, message) => {
switch iframeRef->Nullable.toOption {
| Some(ref) =>
try {
ref
->contentWindow
->sendPostMessage(message)
} catch {
| _ => ()
}
| None => Console.error("This element does not exist or is not mounted yet.")
}
}
/* Version Handling */
let version = packageJson.version
/* URL Handling */
let hrefWithoutSearch = Location.origin ++ Location.pathname
/* iFrame Detection */
let isIframed = () =>
try {
Location.href !== Top.Location.href
} catch {
| e => {
let default = true
Js.Console.error3(
"Failed to check whether or not document is within an iframe",
e,
`Using "${default->String.make}" as default (due to DOMException)`,
)
default
}
}
/* Root Hostname Retrieval */
let getRootHostName = () =>
switch isIframed() {
| true =>
try {
Top.Location.hostname
} catch {
| e => {
let default = Location.hostname
Js.Console.error3(
"Failed to get root document's hostname",
e,
`Using "${default}" [window.location.hostname] as default`,
)
default
}
}
| false => Location.hostname
}
| 1,845 | 10,329 |
hyperswitch-web
|
src/PaymentDetails.res
|
.res
|
type paymentDetails = {
type_: string,
icon: option<React.element>,
displayName: string,
}
let defaultPaymentDetails = {
type_: "",
icon: None,
displayName: "",
}
let icon = (~size=22, ~width=size, name) => {
<Icon size width name />
}
let details = [
{
type_: "card",
icon: Some(icon("default-card", ~size=19)),
displayName: "Card",
},
{
type_: "crypto_currency",
icon: Some(icon("crypto", ~size=19)),
displayName: "Crypto",
},
{
type_: "klarna",
icon: Some(icon("klarna", ~size=19)),
displayName: "Klarna",
},
{
type_: "afterpay_clearpay",
icon: Some(icon("afterpay", ~size=19)),
displayName: "After Pay",
},
{
type_: "affirm",
icon: Some(icon("affirm", ~size=19)),
displayName: "Affirm",
},
{
type_: "sofort",
icon: Some(icon("sofort", ~size=19)),
displayName: "Sofort",
},
{
type_: "ach_transfer",
icon: Some(icon("ach", ~size=19)),
displayName: "ACH Transfer",
},
{
type_: "sepa_bank_transfer",
icon: Some(icon("ach", ~size=19)),
displayName: "Sepa Transfer",
},
{
type_: "instant_bank_transfer",
icon: Some(icon("bank", ~size=19)),
displayName: "Instant Transfer",
},
{
type_: "bacs_transfer",
icon: Some(icon("ach", ~size=19)),
displayName: "Bacs Transfer",
},
{
type_: "giropay",
icon: Some(icon("giropay", ~size=19, ~width=25)),
displayName: "GiroPay",
},
{
type_: "eps",
icon: Some(icon("eps", ~size=19, ~width=25)),
displayName: "EPS",
},
{
type_: "ideal",
icon: Some(icon("ideal", ~size=19, ~width=25)),
displayName: "iDEAL",
},
{
type_: "ban_connect",
icon: None,
displayName: "Ban Connect",
},
{
type_: "ach_debit",
icon: Some(icon("ach", ~size=19)),
displayName: "ACH Debit",
},
{
type_: "sepa_debit",
icon: Some(icon("sepa", ~size=19, ~width=25)),
displayName: "SEPA Debit",
},
{
type_: "bacs_debit",
icon: Some(icon("bank", ~size=21)),
displayName: "BACS Debit",
},
{
type_: "becs_debit",
icon: Some(icon("bank", ~size=21)),
displayName: "BECS Debit",
},
{
type_: "boleto",
icon: Some(icon("boleto", ~size=21)),
displayName: "Boleto",
},
{
type_: "eft",
icon: Some(icon("eft", ~size=19)),
displayName: "eft",
},
]
| 758 | 10,330 |
hyperswitch-web
|
src/Country.res
|
.res
|
type windowsTimeZones = {
id: string,
name: string,
}
type timezoneType = {
isoAlpha3: string,
timeZones: array<string>,
countryName: string,
isoAlpha2: string,
}
let defaultTimeZone = {
isoAlpha3: "",
timeZones: [],
countryName: "-",
isoAlpha2: "",
}
let country = [
{
isoAlpha3: "AFG",
timeZones: ["Asia/Kabul"],
countryName: "Afghanistan",
isoAlpha2: "AF",
},
{
isoAlpha3: "ALA",
timeZones: ["Europe/Mariehamn"],
countryName: `Åland Islands`,
isoAlpha2: "AX",
},
{
isoAlpha3: "ALB",
timeZones: ["Europe/Tirane"],
countryName: "Albania",
isoAlpha2: "AL",
},
{
isoAlpha3: "DZA",
timeZones: ["Africa/Algiers"],
countryName: "Algeria",
isoAlpha2: "DZ",
},
{
isoAlpha3: "ASM",
timeZones: ["Pacific/Pago_Pago"],
countryName: "American Samoa",
isoAlpha2: "AS",
},
{
isoAlpha3: "AND",
timeZones: ["Europe/Andorra"],
countryName: "Andorra",
isoAlpha2: "AD",
},
{
isoAlpha3: "AGO",
timeZones: ["Africa/Luanda"],
countryName: "Angola",
isoAlpha2: "AO",
},
{
isoAlpha3: "AIA",
timeZones: ["America/Anguilla"],
countryName: "Anguilla",
isoAlpha2: "AI",
},
{
isoAlpha3: "ATA",
timeZones: ["Antarctica/Palmer"],
countryName: "Antarctica",
isoAlpha2: "AQ",
},
{
isoAlpha3: "ATG",
timeZones: ["America/Antigua"],
countryName: "Antigua and Barbuda",
isoAlpha2: "AG",
},
{
isoAlpha3: "ARG",
timeZones: [
"America/Argentina/Buenos_Aires",
"America/Argentina/Cordoba",
"America/Argentina/Salta",
"America/Argentina/Jujuy",
"America/Argentina/Tucuman",
"America/Argentina/Catamarca",
"America/Argentina/La_Rioja",
"America/Argentina/San_Juan",
"America/Argentina/Mendoza",
"America/Argentina/San_Luis",
"America/Argentina/Rio_Gallegos",
"America/Argentina/Ushuaia",
],
countryName: "Argentina",
isoAlpha2: "AR",
},
{
isoAlpha3: "ARM",
timeZones: ["Asia/Yerevan"],
countryName: "Armenia",
isoAlpha2: "AM",
},
{
isoAlpha3: "ABW",
timeZones: ["America/Aruba"],
countryName: "Aruba",
isoAlpha2: "AW",
},
{
isoAlpha3: "AUS",
timeZones: [
"Australia/Lord_Howe",
"Antarctica/Macquarie",
"Australia/Hobart",
"Australia/Currie",
"Australia/Melbourne",
"Australia/Sydney",
"Australia/Broken_Hill",
"Australia/Brisbane",
"Australia/Lindeman",
"Australia/Adelaide",
"Australia/Darwin",
"Australia/Perth",
"Australia/Eucla",
],
countryName: "Australia",
isoAlpha2: "AU",
},
{
isoAlpha3: "AUT",
timeZones: ["Europe/Vienna"],
countryName: "Austria",
isoAlpha2: "AT",
},
{
isoAlpha3: "AZE",
timeZones: ["Asia/Baku"],
countryName: "Azerbaijan",
isoAlpha2: "AZ",
},
{
isoAlpha3: "BHS",
timeZones: ["America/Nassau"],
countryName: "Bahamas",
isoAlpha2: "BS",
},
{
isoAlpha3: "BHR",
timeZones: ["Asia/Bahrain"],
countryName: "Bahrain",
isoAlpha2: "BH",
},
{
isoAlpha3: "BGD",
timeZones: ["Asia/Dhaka"],
countryName: "Bangladesh",
isoAlpha2: "BD",
},
{
isoAlpha3: "BRB",
timeZones: ["America/Barbados"],
countryName: "Barbados",
isoAlpha2: "BB",
},
{
isoAlpha3: "BLR",
timeZones: ["Europe/Minsk"],
countryName: "Belarus",
isoAlpha2: "BY",
},
{
isoAlpha3: "BEL",
timeZones: ["Europe/Brussels"],
countryName: "Belgium",
isoAlpha2: "BE",
},
{
isoAlpha3: "BLZ",
timeZones: ["America/Belize"],
countryName: "Belize",
isoAlpha2: "BZ",
},
{
isoAlpha3: "BEN",
timeZones: ["Africa/Porto-Novo"],
countryName: "Benin",
isoAlpha2: "BJ",
},
{
isoAlpha3: "BMU",
timeZones: ["Atlantic/Bermuda"],
countryName: "Bermuda",
isoAlpha2: "BM",
},
{
isoAlpha3: "BTN",
timeZones: ["Asia/Thimphu"],
countryName: "Bhutan",
isoAlpha2: "BT",
},
{
isoAlpha3: "BOL",
timeZones: ["America/La_Paz"],
countryName: "Bolivia",
isoAlpha2: "BO",
},
{
isoAlpha3: "BES",
timeZones: ["America/Kralendijk"],
countryName: "Bonaire, Sint Eustatius and Saba",
isoAlpha2: "BQ",
},
{
isoAlpha3: "BIH",
timeZones: ["Europe/Sarajevo"],
countryName: "Bosnia and Herzegovina",
isoAlpha2: "BA",
},
{
isoAlpha3: "BWA",
timeZones: ["Africa/Gaborone"],
countryName: "Botswana",
isoAlpha2: "BW",
},
{
isoAlpha3: "BVT",
timeZones: ["Africa/Porto-Novo"],
countryName: "Bouvet Island",
isoAlpha2: "BV",
},
{
isoAlpha3: "BRA",
timeZones: [
"America/Noronha",
"America/Belem",
"America/Fortaleza",
"America/Recife",
"America/Araguaina",
"America/Maceio",
"America/Bahia",
"America/Sao_Paulo",
"America/Campo_Grande",
"America/Cuiaba",
"America/Santarem",
"America/Porto_Velho",
"America/Boa_Vista",
"America/Manaus",
"America/Eirunepe",
"America/Rio_Branco",
],
countryName: "Brazil",
isoAlpha2: "BR",
},
{
isoAlpha3: "IOT",
timeZones: ["Indian/Chagos"],
countryName: "British Indian Ocean Territory",
isoAlpha2: "IO",
},
{
isoAlpha3: "BRN",
timeZones: ["Asia/Brunei"],
countryName: "Brunei",
isoAlpha2: "BN",
},
{
isoAlpha3: "BGR",
timeZones: ["Europe/Sofia"],
countryName: "Bulgaria",
isoAlpha2: "BG",
},
{
isoAlpha3: "BFA",
timeZones: ["Africa/Ouagadougou"],
countryName: "Burkina Faso",
isoAlpha2: "BF",
},
{
isoAlpha3: "BDI",
timeZones: ["Africa/Bujumbura"],
countryName: "Burundi",
isoAlpha2: "BI",
},
{
isoAlpha3: "CPV",
timeZones: ["Atlantic/Cape_Verde"],
countryName: "Cabo Verde",
isoAlpha2: "CV",
},
{
isoAlpha3: "KHM",
timeZones: ["Asia/Phnom_Penh"],
countryName: "Cambodia",
isoAlpha2: "KH",
},
{
isoAlpha3: "CMR",
timeZones: ["Africa/Douala"],
countryName: "Cameroon",
isoAlpha2: "CM",
},
{
isoAlpha3: "CAN",
timeZones: [
"America/St_Johns",
"America/Halifax",
"America/Glace_Bay",
"America/Moncton",
"America/Goose_Bay",
"America/Blanc-Sablon",
"America/Toronto",
"America/Nipigon",
"America/Thunder_Bay",
"America/Iqaluit",
"America/Pangnirtung",
"America/Atikokan",
"America/Winnipeg",
"America/Rainy_River",
"America/Resolute",
"America/Rankin_Inlet",
"America/Regina",
"America/Swift_Current",
"America/Edmonton",
"America/Cambridge_Bay",
"America/Yellowknife",
"America/Inuvik",
"America/Creston",
"America/Dawson_Creek",
"America/Fort_Nelson",
"America/Vancouver",
"America/Whitehorse",
"America/Dawson",
],
countryName: "Canada",
isoAlpha2: "CA",
},
{
isoAlpha3: "CYM",
timeZones: ["America/Cayman"],
countryName: "Cayman Islands",
isoAlpha2: "KY",
},
{
isoAlpha3: "CAF",
timeZones: ["Africa/Bangui"],
countryName: "Central African Republic",
isoAlpha2: "CF",
},
{
isoAlpha3: "TCD",
timeZones: ["Africa/Ndjamena"],
countryName: "Chad",
isoAlpha2: "TD",
},
{
isoAlpha3: "CHL",
timeZones: ["America/Santiago", "Pacific/Easter"],
countryName: "Chile",
isoAlpha2: "CL",
},
{
isoAlpha3: "CHN",
timeZones: ["Asia/Shanghai", "Asia/Urumqi"],
countryName: "China",
isoAlpha2: "CN",
},
{
isoAlpha3: "CXR",
timeZones: ["Indian/Christmas"],
countryName: "Christmas Island",
isoAlpha2: "CX",
},
{
isoAlpha3: "CCK",
timeZones: ["Indian/Cocos"],
countryName: "Cocos (Keeling) Islands",
isoAlpha2: "CC",
},
{
isoAlpha3: "COL",
timeZones: ["America/Bogota"],
countryName: "Colombia",
isoAlpha2: "CO",
},
{
isoAlpha3: "COM",
timeZones: ["Indian/Comoro"],
countryName: "Comoros",
isoAlpha2: "KM",
},
{
isoAlpha3: "COG",
timeZones: ["Africa/Brazzaville"],
countryName: "Congo",
isoAlpha2: "CG",
},
{
isoAlpha3: "COD",
timeZones: ["Africa/Kinshasa", "Africa/Lubumbashi"],
countryName: "Congo (DRC)",
isoAlpha2: "CD",
},
{
isoAlpha3: "COK",
timeZones: ["Pacific/Rarotonga"],
countryName: "Cook Islands",
isoAlpha2: "CK",
},
{
isoAlpha3: "CRI",
timeZones: ["America/Costa_Rica"],
countryName: "Costa Rica",
isoAlpha2: "CR",
},
{
isoAlpha3: "CIV",
timeZones: ["Africa/Abidjan"],
countryName: `Côte d’Ivoire`,
isoAlpha2: "CI",
},
{
isoAlpha3: "HRV",
timeZones: ["Europe/Zagreb"],
countryName: "Croatia",
isoAlpha2: "HR",
},
{
isoAlpha3: "CUB",
timeZones: ["America/Havana"],
countryName: "Cuba",
isoAlpha2: "CU",
},
{
isoAlpha3: "CUW",
timeZones: ["America/Curacao"],
countryName: `Curaçao`,
isoAlpha2: "CW",
},
{
isoAlpha3: "CYP",
timeZones: ["Asia/Nicosia"],
countryName: "Cyprus",
isoAlpha2: "CY",
},
{
isoAlpha3: "CZE",
timeZones: ["Europe/Prague"],
countryName: "Czech Republic",
isoAlpha2: "CZ",
},
{
isoAlpha3: "DNK",
timeZones: ["Europe/Copenhagen"],
countryName: "Denmark",
isoAlpha2: "DK",
},
{
isoAlpha3: "DJI",
timeZones: ["Africa/Djibouti"],
countryName: "Djibouti",
isoAlpha2: "DJ",
},
{
isoAlpha3: "DMA",
timeZones: ["America/Dominica"],
countryName: "Dominica",
isoAlpha2: "DM",
},
{
isoAlpha3: "DOM",
timeZones: ["America/Santo_Domingo"],
countryName: "Dominican Republic",
isoAlpha2: "DO",
},
{
isoAlpha3: "ECU",
timeZones: ["America/Guayaquil", "Pacific/Galapagos"],
countryName: "Ecuador",
isoAlpha2: "EC",
},
{
isoAlpha3: "EGY",
timeZones: ["Africa/Cairo"],
countryName: "Egypt",
isoAlpha2: "EG",
},
{
isoAlpha3: "SLV",
timeZones: ["America/El_Salvador"],
countryName: "El Salvador",
isoAlpha2: "SV",
},
{
isoAlpha3: "GNQ",
timeZones: ["Africa/Malabo"],
countryName: "Equatorial Guinea",
isoAlpha2: "GQ",
},
{
isoAlpha3: "ERI",
timeZones: ["Africa/Asmara"],
countryName: "Eritrea",
isoAlpha2: "ER",
},
{
isoAlpha3: "EST",
timeZones: ["Europe/Tallinn"],
countryName: "Estonia",
isoAlpha2: "EE",
},
{
isoAlpha3: "SWZ",
timeZones: ["Africa/Mbabane"],
countryName: "Eswatini",
isoAlpha2: "SZ",
},
{
isoAlpha3: "ETH",
timeZones: ["Africa/Addis_Ababa"],
countryName: "Ethiopia",
isoAlpha2: "ET",
},
{
isoAlpha3: "FLK",
timeZones: ["Atlantic/Stanley"],
countryName: "Falkland Islands (Malvinas)",
isoAlpha2: "FK",
},
{
isoAlpha3: "FRO",
timeZones: ["Atlantic/Faroe"],
countryName: "Faroe Islands",
isoAlpha2: "FO",
},
{
isoAlpha3: "FJI",
timeZones: ["Pacific/Fiji"],
countryName: "Fiji",
isoAlpha2: "FJ",
},
{
isoAlpha3: "FIN",
timeZones: ["Europe/Helsinki"],
countryName: "Finland",
isoAlpha2: "FI",
},
{
isoAlpha3: "FRA",
timeZones: ["Europe/Paris"],
countryName: "France",
isoAlpha2: "FR",
},
{
isoAlpha3: "GUF",
timeZones: ["America/Cayenne"],
countryName: "French Guiana",
isoAlpha2: "GF",
},
{
isoAlpha3: "PYF",
timeZones: ["Pacific/Tahiti", "Pacific/Marquesas", "Pacific/Gambier"],
countryName: "French Polynesia",
isoAlpha2: "PF",
},
{
isoAlpha3: "ATF",
timeZones: ["Indian/Kerguelen"],
countryName: "French Southern Territories",
isoAlpha2: "TF",
},
{
isoAlpha3: "GAB",
timeZones: ["Africa/Libreville"],
countryName: "Gabon",
isoAlpha2: "GA",
},
{
isoAlpha3: "GMB",
timeZones: ["Africa/Banjul"],
countryName: "Gambia",
isoAlpha2: "GM",
},
{
isoAlpha3: "GEO",
timeZones: ["Asia/Tbilisi"],
countryName: "Georgia",
isoAlpha2: "GE",
},
{
isoAlpha3: "DEU",
timeZones: ["Europe/Berlin", "Europe/Busingen"],
countryName: "Germany",
isoAlpha2: "DE",
},
{
isoAlpha3: "GHA",
timeZones: ["Africa/Accra"],
countryName: "Ghana",
isoAlpha2: "GH",
},
{
isoAlpha3: "GIB",
timeZones: ["Europe/Gibraltar"],
countryName: "Gibraltar",
isoAlpha2: "GI",
},
{
isoAlpha3: "GRC",
timeZones: ["Europe/Athens"],
countryName: "Greece",
isoAlpha2: "GR",
},
{
isoAlpha3: "GRL",
timeZones: ["America/Godthab", "America/Danmarkshavn", "America/Scoresbysund", "America/Thule"],
countryName: "Greenland",
isoAlpha2: "GL",
},
{
isoAlpha3: "GRD",
timeZones: ["America/Grenada"],
countryName: "Grenada",
isoAlpha2: "GD",
},
{
isoAlpha3: "GLP",
timeZones: ["America/Guadeloupe"],
countryName: "Guadeloupe",
isoAlpha2: "GP",
},
{
isoAlpha3: "GUM",
timeZones: ["Pacific/Guam"],
countryName: "Guam",
isoAlpha2: "GU",
},
{
isoAlpha3: "GTM",
timeZones: ["America/Guatemala"],
countryName: "Guatemala",
isoAlpha2: "GT",
},
{
isoAlpha3: "GGY",
timeZones: ["Europe/Guernsey"],
countryName: "Guernsey",
isoAlpha2: "GG",
},
{
isoAlpha3: "GIN",
timeZones: ["Africa/Conakry"],
countryName: "Guinea",
isoAlpha2: "GN",
},
{
isoAlpha3: "GNB",
timeZones: ["Africa/Bissau"],
countryName: "Guinea-Bissau",
isoAlpha2: "GW",
},
{
isoAlpha3: "GUY",
timeZones: ["America/Guyana"],
countryName: "Guyana",
isoAlpha2: "GY",
},
{
isoAlpha3: "HTI",
timeZones: ["America/Port-au-Prince"],
countryName: "Haiti",
isoAlpha2: "HT",
},
{
isoAlpha3: "HMD",
timeZones: ["Indian/Kerguelen"],
countryName: "Heard Island and McDonald Islands",
isoAlpha2: "HM",
},
{
isoAlpha3: "VAT",
timeZones: ["Europe/Vatican"],
countryName: "Holy See (Vatican City State)",
isoAlpha2: "VA",
},
{
isoAlpha3: "HND",
timeZones: ["America/Tegucigalpa"],
countryName: "Honduras",
isoAlpha2: "HN",
},
{
isoAlpha3: "HKG",
timeZones: ["Asia/Hong_Kong"],
countryName: "Hong Kong SAR",
isoAlpha2: "HK",
},
{
isoAlpha3: "HUN",
timeZones: ["Europe/Budapest"],
countryName: "Hungary",
isoAlpha2: "HU",
},
{
isoAlpha3: "ISL",
timeZones: ["Atlantic/Reykjavik"],
countryName: "Iceland",
isoAlpha2: "IS",
},
{
isoAlpha3: "IND",
timeZones: ["Asia/Kolkata", "Asia/Calcutta"],
countryName: "India",
isoAlpha2: "IN",
},
{
isoAlpha3: "IDN",
timeZones: ["Asia/Jakarta", "Asia/Pontianak", "Asia/Makassar", "Asia/Jayapura"],
countryName: "Indonesia",
isoAlpha2: "ID",
},
{
isoAlpha3: "IRN",
timeZones: ["Asia/Tehran"],
countryName: "Iran",
isoAlpha2: "IR",
},
{
isoAlpha3: "IRQ",
timeZones: ["Asia/Baghdad"],
countryName: "Iraq",
isoAlpha2: "IQ",
},
{
isoAlpha3: "IRL",
timeZones: ["Europe/Dublin"],
countryName: "Ireland",
isoAlpha2: "IE",
},
{
isoAlpha3: "IMN",
timeZones: ["Europe/Isle_of_Man"],
countryName: "Isle of Man",
isoAlpha2: "IM",
},
{
isoAlpha3: "ISR",
timeZones: ["Asia/Jerusalem"],
countryName: "Israel",
isoAlpha2: "IL",
},
{
isoAlpha3: "ITA",
timeZones: ["Europe/Rome"],
countryName: "Italy",
isoAlpha2: "IT",
},
{
isoAlpha3: "JAM",
timeZones: ["America/Jamaica"],
countryName: "Jamaica",
isoAlpha2: "JM",
},
{
isoAlpha3: "JPN",
timeZones: ["Asia/Tokyo"],
countryName: "Japan",
isoAlpha2: "JP",
},
{
isoAlpha3: "JEY",
timeZones: ["Europe/Jersey"],
countryName: "Jersey",
isoAlpha2: "JE",
},
{
isoAlpha3: "JOR",
timeZones: ["Asia/Amman"],
countryName: "Jordan",
isoAlpha2: "JO",
},
{
isoAlpha3: "KAZ",
timeZones: ["Asia/Almaty", "Asia/Qyzylorda", "Asia/Aqtobe", "Asia/Aqtau", "Asia/Oral"],
countryName: "Kazakhstan",
isoAlpha2: "KZ",
},
{
isoAlpha3: "KEN",
timeZones: ["Africa/Nairobi"],
countryName: "Kenya",
isoAlpha2: "KE",
},
{
isoAlpha3: "KIR",
timeZones: ["Pacific/Tarawa"],
countryName: "Kiribati",
isoAlpha2: "KI",
},
{
isoAlpha3: "KOR",
timeZones: ["Asia/Seoul"],
countryName: "Korea",
isoAlpha2: "KR",
},
{
isoAlpha3: "PRK",
timeZones: ["Asia/Pyongyang"],
countryName: "Korea (Democratic People's Republic of)",
isoAlpha2: "KP",
},
{
isoAlpha3: "KWT",
timeZones: ["Asia/Kuwait"],
countryName: "Kuwait",
isoAlpha2: "KW",
},
{
isoAlpha3: "KGZ",
timeZones: ["Asia/Bishkek"],
countryName: "Kyrgyzstan",
isoAlpha2: "KG",
},
{
isoAlpha3: "LAO",
timeZones: ["Asia/Vientiane"],
countryName: "Laos",
isoAlpha2: "LA",
},
{
isoAlpha3: "LVA",
timeZones: ["Europe/Riga"],
countryName: "Latvia",
isoAlpha2: "LV",
},
{
isoAlpha3: "LBN",
timeZones: ["Asia/Beirut"],
countryName: "Lebanon",
isoAlpha2: "LB",
},
{
isoAlpha3: "LSO",
timeZones: ["Africa/Maseru"],
countryName: "Lesotho",
isoAlpha2: "LS",
},
{
isoAlpha3: "LBR",
timeZones: ["Africa/Monrovia"],
countryName: "Liberia",
isoAlpha2: "LR",
},
{
isoAlpha3: "LBY",
timeZones: ["Africa/Tripoli"],
countryName: "Libya",
isoAlpha2: "LY",
},
{
isoAlpha3: "LIE",
timeZones: ["Europe/Vaduz"],
countryName: "Liechtenstein",
isoAlpha2: "LI",
},
{
isoAlpha3: "LTU",
timeZones: ["Europe/Vilnius"],
countryName: "Lithuania",
isoAlpha2: "LT",
},
{
isoAlpha3: "LUX",
timeZones: ["Europe/Luxembourg"],
countryName: "Luxembourg",
isoAlpha2: "LU",
},
{
isoAlpha3: "MAC",
timeZones: ["Asia/Macau"],
countryName: "Macao SAR",
isoAlpha2: "MO",
},
{
isoAlpha3: "MKD",
timeZones: ["Europe/Skopje"],
countryName: "Macedonia, FYRO",
isoAlpha2: "MK",
},
{
isoAlpha3: "MDG",
timeZones: ["Indian/Antananarivo"],
countryName: "Madagascar",
isoAlpha2: "MG",
},
{
isoAlpha3: "MWI",
timeZones: ["Africa/Blantyre"],
countryName: "Malawi",
isoAlpha2: "MW",
},
{
isoAlpha3: "MYS",
timeZones: ["Asia/Kuala_Lumpur", "Asia/Kuching"],
countryName: "Malaysia",
isoAlpha2: "MY",
},
{
isoAlpha3: "MDV",
timeZones: ["Indian/Maldives"],
countryName: "Maldives",
isoAlpha2: "MV",
},
{
isoAlpha3: "MLI",
timeZones: ["Africa/Bamako"],
countryName: "Mali",
isoAlpha2: "ML",
},
{
isoAlpha3: "MLT",
timeZones: ["Europe/Malta"],
countryName: "Malta",
isoAlpha2: "MT",
},
{
isoAlpha3: "MHL",
timeZones: ["Pacific/Majuro"],
countryName: "Marshall Islands",
isoAlpha2: "MH",
},
{
isoAlpha3: "MTQ",
timeZones: ["America/Martinique"],
countryName: "Martinique",
isoAlpha2: "MQ",
},
{
isoAlpha3: "MRT",
timeZones: ["Africa/Nouakchott"],
countryName: "Mauritania",
isoAlpha2: "MR",
},
{
isoAlpha3: "MUS",
timeZones: ["Indian/Mauritius"],
countryName: "Mauritius",
isoAlpha2: "MU",
},
{
isoAlpha3: "YT",
timeZones: ["Indian/Mayotte"],
countryName: "Mayotte",
isoAlpha2: "YT",
},
{
isoAlpha3: "MEX",
timeZones: [
"America/Mexico_City",
"America/Cancun",
"America/Merida",
"America/Monterrey",
"America/Matamoros",
"America/Mazatlan",
"America/Chihuahua",
"America/Ojinaga",
"America/Hermosillo",
"America/Tijuana",
"America/Bahia_Banderas",
],
countryName: "Mexico",
isoAlpha2: "MX",
},
{
isoAlpha3: "FSM",
timeZones: ["Pacific/Chuuk", "Pacific/Pohnpei", "Pacific/Kosrae"],
countryName: "Micronesia, Federated States of",
isoAlpha2: "FM",
},
{
isoAlpha3: "MDA",
timeZones: ["Europe/Chisinau"],
countryName: "Moldova",
isoAlpha2: "MD",
},
{
isoAlpha3: "MCO",
timeZones: ["Europe/Monaco"],
countryName: "Monaco",
isoAlpha2: "MC",
},
{
isoAlpha3: "MNG",
timeZones: ["Asia/Ulaanbaatar", "Asia/Hovd", "Asia/Choibalsan"],
countryName: "Mongolia",
isoAlpha2: "MN",
},
{
isoAlpha3: "MNE",
timeZones: ["Europe/Podgorica"],
countryName: "Montenegro",
isoAlpha2: "ME",
},
{
isoAlpha3: "MSR",
timeZones: ["America/Montserrat"],
countryName: "Montserrat",
isoAlpha2: "MS",
},
{
isoAlpha3: "MAR",
timeZones: ["Africa/Casablanca"],
countryName: "Morocco",
isoAlpha2: "MA",
},
{
isoAlpha3: "MOZ",
timeZones: ["Africa/Maputo"],
countryName: "Mozambique",
isoAlpha2: "MZ",
},
{
isoAlpha3: "MMR",
timeZones: ["Asia/Rangoon"],
countryName: "Myanmar",
isoAlpha2: "MM",
},
{
isoAlpha3: "NAM",
timeZones: ["Africa/Windhoek"],
countryName: "Namibia",
isoAlpha2: "NA",
},
{
isoAlpha3: "NRU",
timeZones: ["Pacific/Nauru"],
countryName: "Nauru",
isoAlpha2: "NR",
},
{
isoAlpha3: "NPL",
timeZones: ["Asia/Kathmandu"],
countryName: "Nepal",
isoAlpha2: "NP",
},
{
isoAlpha3: "NLD",
timeZones: ["Europe/Amsterdam"],
countryName: "Netherlands",
isoAlpha2: "NL",
},
{
isoAlpha3: "NCL",
timeZones: ["Pacific/Noumea"],
countryName: "New Caledonia",
isoAlpha2: "NC",
},
{
isoAlpha3: "NZL",
timeZones: ["Pacific/Auckland", "Pacific/Chatham"],
countryName: "New Zealand",
isoAlpha2: "NZ",
},
{
isoAlpha3: "NIC",
timeZones: ["America/Managua"],
countryName: "Nicaragua",
isoAlpha2: "NI",
},
{
isoAlpha3: "NER",
timeZones: ["Africa/Niamey"],
countryName: "Niger",
isoAlpha2: "NE",
},
{
isoAlpha3: "NGA",
timeZones: ["Africa/Lagos"],
countryName: "Nigeria",
isoAlpha2: "NG",
},
{
isoAlpha3: "NIU",
timeZones: ["Pacific/Niue"],
countryName: "Niue",
isoAlpha2: "NU",
},
{
isoAlpha3: "NFK",
timeZones: ["Pacific/Norfolk"],
countryName: "Norfolk Island",
isoAlpha2: "NF",
},
{
isoAlpha3: "MNP",
timeZones: ["Pacific/Saipan"],
countryName: "Northern Mariana Islands",
isoAlpha2: "MP",
},
{
isoAlpha3: "NOR",
timeZones: ["Europe/Oslo"],
countryName: "Norway",
isoAlpha2: "NO",
},
{
isoAlpha3: "OMN",
timeZones: ["Asia/Muscat"],
countryName: "Oman",
isoAlpha2: "OM",
},
{
isoAlpha3: "PAK",
timeZones: ["Asia/Karachi"],
countryName: "Pakistan",
isoAlpha2: "PK",
},
{
isoAlpha3: "PLW",
timeZones: ["Pacific/Palau"],
countryName: "Palau",
isoAlpha2: "PW",
},
{
isoAlpha3: "PSE",
timeZones: ["Asia/Gaza", "Asia/Hebron"],
countryName: "Palestine, State of",
isoAlpha2: "PS",
},
{
isoAlpha3: "PAN",
timeZones: ["America/Panama"],
countryName: "Panama",
isoAlpha2: "PA",
},
{
isoAlpha3: "PNG",
timeZones: ["Pacific/Port_Moresby"],
countryName: "Papua New Guinea",
isoAlpha2: "PG",
},
{
isoAlpha3: "PRY",
timeZones: ["America/Asuncion"],
countryName: "Paraguay",
isoAlpha2: "PY",
},
{
isoAlpha3: "PER",
timeZones: ["America/Lima"],
countryName: "Peru",
isoAlpha2: "PE",
},
{
isoAlpha3: "PHL",
timeZones: ["Asia/Manila"],
countryName: "Philippines",
isoAlpha2: "PH",
},
{
isoAlpha3: "PCN",
timeZones: ["Pacific/Pitcairn"],
countryName: "Pitcairn",
isoAlpha2: "PN",
},
{
isoAlpha3: "POL",
timeZones: ["Europe/Warsaw"],
countryName: "Poland",
isoAlpha2: "PL",
},
{
isoAlpha3: "PRT",
timeZones: ["Europe/Lisbon", "Atlantic/Madeira", "Atlantic/Azores"],
countryName: "Portugal",
isoAlpha2: "PT",
},
{
isoAlpha3: "PRI",
timeZones: ["America/Puerto_Rico"],
countryName: "Puerto Rico",
isoAlpha2: "PR",
},
{
isoAlpha3: "QAT",
timeZones: ["Asia/Qatar"],
countryName: "Qatar",
isoAlpha2: "QA",
},
{
isoAlpha3: "REU",
timeZones: ["Indian/Reunion"],
countryName: `Réunion`,
isoAlpha2: "RE",
},
{
isoAlpha3: "ROU",
timeZones: ["Europe/Bucharest"],
countryName: "Romania",
isoAlpha2: "RO",
},
{
isoAlpha3: "RUS",
timeZones: [
"Europe/Kaliningrad",
"Europe/Moscow",
"Europe/Simferopol",
"Europe/Volgograd",
"Europe/Astrakhan",
"Europe/Samara",
"Europe/Ulyanovsk",
"Asia/Yekaterinburg",
"Asia/Omsk",
"Asia/Novosibirsk",
"Asia/Barnaul",
"Asia/Novokuznetsk",
"Asia/Krasnoyarsk",
"Asia/Irkutsk",
"Asia/Chita",
"Asia/Yakutsk",
"Asia/Khandyga",
"Asia/Vladivostok",
"Asia/Ust-Nera",
"Asia/Magadan",
"Asia/Sakhalin",
"Asia/Srednekolymsk",
"Asia/Kamchatka",
"Asia/Anadyr",
],
countryName: "Russia",
isoAlpha2: "RU",
},
{
isoAlpha3: "RWA",
timeZones: ["Africa/Kigali"],
countryName: "Rwanda",
isoAlpha2: "RW",
},
{
isoAlpha3: "BLM",
timeZones: ["America/St_Barthelemy"],
countryName: `Saint Barthélemy`,
isoAlpha2: "BL",
},
{
isoAlpha3: "SHN",
timeZones: ["Atlantic/St_Helena"],
countryName: "Saint Helena, Ascension and Tristan da Cunha",
isoAlpha2: "SH",
},
{
isoAlpha3: "KNA",
timeZones: ["America/St_Kitts"],
countryName: "Saint Kitts and Nevis",
isoAlpha2: "KN",
},
{
isoAlpha3: "LCA",
timeZones: ["America/St_Lucia"],
countryName: "Saint Lucia",
isoAlpha2: "LC",
},
{
isoAlpha3: "MAF",
timeZones: ["America/Marigot"],
countryName: "Saint Martin (French part)",
isoAlpha2: "MF",
},
{
isoAlpha3: "SPM",
timeZones: ["America/Miquelon"],
countryName: "Saint Pierre and Miquelon",
isoAlpha2: "PM",
},
{
isoAlpha3: "VCT",
timeZones: ["America/St_Vincent"],
countryName: "Saint Vincent and the Grenadines",
isoAlpha2: "VC",
},
{
isoAlpha3: "WSM",
timeZones: ["Pacific/Apia"],
countryName: "Samoa",
isoAlpha2: "WS",
},
{
isoAlpha3: "SMR",
timeZones: ["Europe/San_Marino"],
countryName: "San Marino",
isoAlpha2: "SM",
},
{
isoAlpha3: "STP",
timeZones: ["Africa/Sao_Tome"],
countryName: "Sao Tome and Principe",
isoAlpha2: "ST",
},
{
isoAlpha3: "SAU",
timeZones: ["Asia/Riyadh"],
countryName: "Saudi Arabia",
isoAlpha2: "SA",
},
{
isoAlpha3: "SEN",
timeZones: ["Africa/Dakar"],
countryName: "Senegal",
isoAlpha2: "SN",
},
{
isoAlpha3: "SRB",
timeZones: ["Europe/Belgrade"],
countryName: "Serbia",
isoAlpha2: "RS",
},
{
isoAlpha3: "SYC",
timeZones: ["Indian/Mahe"],
countryName: "Seychelles",
isoAlpha2: "SC",
},
{
isoAlpha3: "SLE",
timeZones: ["Africa/Freetown"],
countryName: "Sierra Leone",
isoAlpha2: "SL",
},
{
isoAlpha3: "SGP",
timeZones: ["Asia/Singapore"],
countryName: "Singapore",
isoAlpha2: "SG",
},
{
isoAlpha3: "SXM",
timeZones: ["America/Lower_Princes"],
countryName: "Sint Maarten (Dutch part)",
isoAlpha2: "SX",
},
{
isoAlpha3: "SVK",
timeZones: ["Europe/Bratislava"],
countryName: "Slovakia",
isoAlpha2: "SK",
},
{
isoAlpha3: "SVN",
timeZones: ["Europe/Ljubljana"],
countryName: "Slovenia",
isoAlpha2: "SI",
},
{
isoAlpha3: "SLB",
timeZones: ["Pacific/Guadalcanal"],
countryName: "Solomon Islands",
isoAlpha2: "SB",
},
{
isoAlpha3: "SOM",
timeZones: ["Africa/Mogadishu"],
countryName: "Somalia",
isoAlpha2: "SO",
},
{
isoAlpha3: "ZAF",
timeZones: ["Africa/Johannesburg"],
countryName: "South Africa",
isoAlpha2: "ZA",
},
{
isoAlpha3: "SGS",
timeZones: ["Atlantic/South_Georgia"],
countryName: "South Georgia and the South Sandwich Islands",
isoAlpha2: "GS",
},
{
isoAlpha3: "SSD",
timeZones: ["Africa/Juba"],
countryName: "South Sudan",
isoAlpha2: "SS",
},
{
isoAlpha3: "ESP",
timeZones: ["Europe/Madrid", "Africa/Ceuta", "Atlantic/Canary"],
countryName: "Spain",
isoAlpha2: "ES",
},
{
isoAlpha3: "LKA",
timeZones: ["Asia/Colombo"],
countryName: "Sri Lanka",
isoAlpha2: "LK",
},
{
isoAlpha3: "SDN",
timeZones: ["Africa/Khartoum"],
countryName: "Sudan",
isoAlpha2: "SD",
},
{
isoAlpha3: "SUR",
timeZones: ["America/Paramaribo"],
countryName: "Suriname",
isoAlpha2: "SR",
},
{
isoAlpha3: "SJM",
timeZones: ["Arctic/Longyearbyen"],
countryName: "Svalbard and Jan Mayen",
isoAlpha2: "SJ",
},
{
isoAlpha3: "SWE",
timeZones: ["Europe/Stockholm"],
countryName: "Sweden",
isoAlpha2: "SE",
},
{
isoAlpha3: "CHE",
timeZones: ["Europe/Zurich"],
countryName: "Switzerland",
isoAlpha2: "CH",
},
{
isoAlpha3: "SYR",
timeZones: ["Asia/Damascus"],
countryName: "Syria",
isoAlpha2: "SY",
},
{
isoAlpha3: "TWN",
timeZones: ["Asia/Taipei"],
countryName: "Taiwan",
isoAlpha2: "TW",
},
{
isoAlpha3: "TJK",
timeZones: ["Asia/Dushanbe"],
countryName: "Tajikistan",
isoAlpha2: "TJ",
},
{
isoAlpha3: "TZA",
timeZones: ["Africa/Dar_es_Salaam"],
countryName: "Tanzania, United Republic of",
isoAlpha2: "TZ",
},
{
isoAlpha3: "THA",
timeZones: ["Asia/Bangkok"],
countryName: "Thailand",
isoAlpha2: "TH",
},
{
isoAlpha3: "TLS",
timeZones: ["Asia/Dili"],
countryName: "Timor-Leste",
isoAlpha2: "TL",
},
{
isoAlpha3: "TGO",
timeZones: ["Africa/Lome"],
countryName: "Togo",
isoAlpha2: "TG",
},
{
isoAlpha3: "TKL",
timeZones: ["Pacific/Fakaofo"],
countryName: "Tokelau",
isoAlpha2: "TK",
},
{
isoAlpha3: "TON",
timeZones: ["Pacific/Tongatapu"],
countryName: "Tonga",
isoAlpha2: "TO",
},
{
isoAlpha3: "TTO",
timeZones: ["America/Port_of_Spain"],
countryName: "Trinidad and Tobago",
isoAlpha2: "TT",
},
{
isoAlpha3: "TUN",
timeZones: ["Africa/Tunis"],
countryName: "Tunisia",
isoAlpha2: "TN",
},
{
isoAlpha3: "TUR",
timeZones: ["Europe/Istanbul"],
countryName: "Turkey",
isoAlpha2: "TR",
},
{
isoAlpha3: "TKM",
timeZones: ["Asia/Ashgabat"],
countryName: "Turkmenistan",
isoAlpha2: "TM",
},
{
isoAlpha3: "TCA",
timeZones: ["America/Grand_Turk"],
countryName: "Turks and Caicos Islands",
isoAlpha2: "TC",
},
{
isoAlpha3: "TUV",
timeZones: ["Pacific/Funafuti"],
countryName: "Tuvalu",
isoAlpha2: "TV",
},
{
isoAlpha3: "UGA",
timeZones: ["Africa/Kampala"],
countryName: "Uganda",
isoAlpha2: "UG",
},
{
isoAlpha3: "UKR",
timeZones: ["Europe/Kiev", "Europe/Uzhgorod", "Europe/Zaporozhye"],
countryName: "Ukraine",
isoAlpha2: "UA",
},
{
isoAlpha3: "ARE",
timeZones: ["Asia/Dubai"],
countryName: "United Arab Emirates",
isoAlpha2: "AE",
},
{
isoAlpha3: "GBR",
timeZones: ["Europe/London"],
countryName: "United Kingdom",
isoAlpha2: "GB",
},
{
isoAlpha3: "USA",
timeZones: [
"America/New_York",
"America/Detroit",
"America/Kentucky/Louisville",
"America/Kentucky/Monticello",
"America/Indiana/Indianapolis",
"America/Indiana/Vincennes",
"America/Indiana/Winamac",
"America/Indiana/Marengo",
"America/Indiana/Petersburg",
"America/Indiana/Vevay",
"America/Chicago",
"America/Indiana/Tell_City",
"America/Indiana/Knox",
"America/Menominee",
"America/North_Dakota/Center",
"America/North_Dakota/New_Salem",
"America/North_Dakota/Beulah",
"America/Denver",
"America/Boise",
"America/Phoenix",
"America/Los_Angeles",
"America/Anchorage",
"America/Juneau",
"America/Sitka",
"America/Metlakatla",
"America/Yakutat",
"America/Nome",
"America/Adak",
"Pacific/Honolulu",
],
countryName: "United States",
isoAlpha2: "US",
},
{
isoAlpha3: "UMI",
timeZones: ["Pacific/Midway", "Pacific/Wake"],
countryName: "United States Minor Outlying Islands",
isoAlpha2: "UM",
},
{
isoAlpha3: "URY",
timeZones: ["America/Montevideo"],
countryName: "Uruguay",
isoAlpha2: "UY",
},
{
isoAlpha3: "UZB",
timeZones: ["Asia/Samarkand", "Asia/Tashkent"],
countryName: "Uzbekistan",
isoAlpha2: "UZ",
},
{
isoAlpha3: "VUT",
timeZones: ["Pacific/Efate"],
countryName: "Vanuatu",
isoAlpha2: "VU",
},
{
isoAlpha3: "VEN",
timeZones: ["America/Caracas"],
countryName: "Venezuela",
isoAlpha2: "VE",
},
{
isoAlpha3: "VNM",
timeZones: ["Asia/Ho_Chi_Minh"],
countryName: "Vietnam",
isoAlpha2: "VN",
},
{
isoAlpha3: "VGB",
timeZones: ["America/Tortola"],
countryName: "Virgin Islands, British",
isoAlpha2: "VG",
},
{
isoAlpha3: "VIR",
timeZones: ["America/St_Thomas"],
countryName: "Virgin Islands, U.S.",
isoAlpha2: "VI",
},
{
isoAlpha3: "WLF",
timeZones: ["Pacific/Wallis"],
countryName: "Wallis and Futuna",
isoAlpha2: "WF",
},
{
isoAlpha3: "ESH",
timeZones: ["Africa/El_Aaiun"],
countryName: "Western Sahara",
isoAlpha2: "EH",
},
{
isoAlpha3: "YEM",
timeZones: ["Asia/Aden"],
countryName: "Yemen",
isoAlpha2: "YE",
},
{
isoAlpha3: "ZMB",
timeZones: ["Africa/Lusaka"],
countryName: "Zambia",
isoAlpha2: "ZM",
},
{
isoAlpha3: "ZWE",
timeZones: ["Africa/Harare"],
countryName: "Zimbabwe",
isoAlpha2: "ZW",
},
]
let sofortCountries = [
{
isoAlpha3: "AUT",
timeZones: ["Europe/Vienna"],
countryName: "Austria",
isoAlpha2: "AT",
},
{
isoAlpha3: "BEL",
timeZones: ["Europe/Brussels"],
countryName: "Belgium",
isoAlpha2: "BE",
},
{
isoAlpha3: "DEU",
timeZones: ["Europe/Berlin", "Europe/Busingen"],
countryName: "Germany",
isoAlpha2: "DE",
},
{
isoAlpha3: "ITA",
timeZones: ["Europe/Rome"],
countryName: "Italy",
isoAlpha2: "IT",
},
{
isoAlpha3: "NLD",
timeZones: ["Europe/Amsterdam"],
countryName: "Netherlands",
isoAlpha2: "NL",
},
{
isoAlpha3: "ESP",
timeZones: ["Europe/Madrid", "Africa/Ceuta", "Atlantic/Canary"],
countryName: "Spain",
isoAlpha2: "ES",
},
]
let getCountry = paymentMethodName => {
switch paymentMethodName {
| "sofort" => sofortCountries
| _ => country
}
}
| 11,916 | 10,331 |
hyperswitch-web
|
src/ResizeObserver.res
|
.res
|
type observer = {observe: Dom.element => unit, disconnect: unit => unit}
type dimensions = {
height: float,
width: float,
}
type ele = {contentRect: dimensions}
@new external newResizerObserver: (array<ele> => unit) => observer = "ResizeObserver"
| 64 | 10,332 |
hyperswitch-web
|
src/PaymentElementRenderer.resi
|
.resi
|
@react.component
let default: (
~paymentType: CardThemeType.mode,
~cardProps: CardUtils.cardProps,
~expiryProps: CardUtils.expiryProps,
~cvcProps: CardUtils.cvcProps,
) => React.element
| 56 | 10,333 |
hyperswitch-web
|
src/CardSchemeComponent.res
|
.res
|
module CoBadgeCardSchemeDropDown = {
@react.component
let make = (~eligibleCardSchemes, ~setCardBrand) => {
<select
className="w-4"
onChange={ev => {
let target = ev->ReactEvent.Form.target
let value = target["value"]
setCardBrand(_ => value)
}}>
<option disabled=true> {"Select a card brand"->React.string} </option>
{eligibleCardSchemes
->Array.mapWithIndex((item, i) => {
<option key={Int.toString(i)} value=item> {item->React.string} </option>
})
->React.array}
</select>
}
}
@react.component
let make = (~cardNumber, ~paymentType, ~cardBrand, ~setCardBrand) => {
let cardType = React.useMemo1(_ => cardBrand->CardUtils.getCardType, [cardBrand])
let animate = cardType == NOTFOUND ? "animate-slideLeft" : "animate-slideRight"
let cardBrandIcon = React.useMemo1(
_ => CardUtils.getCardBrandIcon(cardType, paymentType),
[cardBrand],
)
let paymentMethodListValue = Recoil.useRecoilValueFromAtom(PaymentUtils.paymentMethodListValue)
let enabledCardSchemes =
paymentMethodListValue->PaymentUtils.getSupportedCardBrands->Option.getOr([])
let matchedCardSchemes = cardNumber->CardUtils.clearSpaces->CardUtils.getAllMatchedCardSchemes
let eligibleCardSchemes = CardUtils.getEligibleCoBadgedCardSchemes(
~matchedCardSchemes,
~enabledCardSchemes,
)
let isCardCoBadged = eligibleCardSchemes->Array.length > 1
let marginLeft = isCardCoBadged ? "-ml-2" : ""
<div className={`${animate} flex items-center ${marginLeft} hellow-rodl`}>
cardBrandIcon
<RenderIf condition={isCardCoBadged && cardNumber->CardUtils.clearSpaces->String.length >= 16}>
<CoBadgeCardSchemeDropDown eligibleCardSchemes setCardBrand />
</RenderIf>
</div>
}
| 475 | 10,334 |
hyperswitch-web
|
src/Index.res
|
.res
|
%%raw(`require("tailwindcss/tailwind.css")`)
%%raw("import './index.css'")
Sentry.initiateSentry(~dsn=GlobalVars.sentryDSN)
let app = switch ReactDOM.querySelector("#app") {
| Some(container) =>
let root = ReactDOM.Client.createRoot(container)
root->ReactDOM.Client.Root.render(
<div className="h-auto flex flex-col ">
<div className="h-auto flex flex-col">
<Recoil.RecoilRoot>
<ErrorBoundary level=ErrorBoundary.Top componentName="App">
<App />
</ErrorBoundary>
</Recoil.RecoilRoot>
</div>
</div>,
)
| None => ()
}
app
| 149 | 10,335 |
hyperswitch-web
|
src/PaymentOptions.res
|
.res
|
open RecoilAtoms
module TabLoader = {
@react.component
let make = (~cardShimmerCount) => {
let paymentMethodList = Recoil.useRecoilValueFromAtom(paymentMethodList)
let {themeObj} = Recoil.useRecoilValueFromAtom(configAtom)
open PaymentType
open PaymentElementShimmer
switch paymentMethodList {
| SemiLoaded =>
Array.make(~length=cardShimmerCount - 1, "")
->Array.mapWithIndex((_, i) => {
<div
className={`Tab flex flex-col gap-3 animate-pulse cursor-default`}
key={i->Int.toString}
style={
minWidth: "5rem",
overflowWrap: "hidden",
width: "100%",
padding: themeObj.spacingUnit,
cursor: "pointer",
}>
<Shimmer classname="opacity-50 w-1/3">
<div
className="w-full h-3 animate-pulse"
style={backgroundColor: themeObj.colorPrimary, opacity: "10%"}
/>
</Shimmer>
<Shimmer classname="opacity-50">
<div
className="w-full h-2 animate-pulse"
style={backgroundColor: themeObj.colorPrimary, opacity: "10%"}
/>
</Shimmer>
</div>
})
->React.array
| _ => React.null
}
}
}
@react.component
let make = (
~setCardsContainerWidth,
~cardOptions: array<string>,
~dropDownOptions: array<string>,
~checkoutEle: React.element,
~cardShimmerCount: int,
~cardProps,
) => {
let {themeObj, localeString} = Recoil.useRecoilValueFromAtom(configAtom)
let {readOnly, customMethodNames} = Recoil.useRecoilValueFromAtom(optionAtom)
let payOptionsRef = React.useRef(Nullable.null)
let selectRef = React.useRef(Nullable.null)
let (winW, winH) = Utils.useWindowSize()
let (selectedOption, setSelectedOption) = Recoil.useRecoilState(selectedOptionAtom)
let (moreIconIndex, setMoreIconIndex) = React.useState(_ => 0)
let (toggleIconElement, setToggleIconElement) = React.useState(_ => false)
let paymentMethodListValue = Recoil.useRecoilValueFromAtom(PaymentUtils.paymentMethodListValue)
React.useEffect(() => {
let width = switch payOptionsRef.current->Nullable.toOption {
| Some(ref) => ref->Window.Element.clientWidth
| None => 0
}
setCardsContainerWidth(_ => width)
None
}, (winH, winW))
let handleChange = ev => {
let target = ev->ReactEvent.Form.target
let value = target["value"]
setSelectedOption(_ => value)
CardUtils.blurRef(selectRef)
}
let cardOptionDetails = cardOptions->PaymentMethodsRecord.getPaymentDetails
let dropDownOptionsDetails = dropDownOptions->PaymentMethodsRecord.getPaymentDetails
let selectedPaymentOption =
PaymentMethodsRecord.paymentMethodsFields
->Array.find(item => item.paymentMethodName == selectedOption)
->Option.getOr(PaymentMethodsRecord.defaultPaymentMethodFields)
let (_, _, _, _, _, _, _, _, _, _, _, cardBrand) = cardProps
React.useEffect(() => {
let intervalId = setInterval(() => {
if dropDownOptionsDetails->Array.length > 1 {
setMoreIconIndex(prev => mod(prev + 1, dropDownOptionsDetails->Array.length))
setToggleIconElement(_ => true)
setTimeout(
() => {
setToggleIconElement(_ => false)
},
10,
)->ignore
}
}, 5000)
Some(
() => {
clearInterval(intervalId)
},
)
}, [dropDownOptionsDetails])
PaymentUtils.useEmitPaymentMethodInfo(
~paymentMethodName=selectedPaymentOption.paymentMethodName,
~paymentMethods=paymentMethodListValue.payment_methods,
~cardBrand,
)
let displayIcon = ele => {
<span className={`scale-90 animate-slowShow ${toggleIconElement ? "hidden" : ""}`}> ele </span>
}
<div className="w-full">
<div
ref={payOptionsRef->ReactDOM.Ref.domRef}
className="flex flex-row overflow-auto no-scrollbar"
dataTestId={TestUtils.paymentMethodListTestId}
style={
columnGap: themeObj.spacingTab,
marginBottom: themeObj.spacingGridColumn,
paddingBottom: "7px",
padding: "4px",
height: "auto",
}>
{cardOptionDetails
->Array.mapWithIndex((payOption, i) => {
let isActive = payOption.paymentMethodName == selectedOption
<TabCard key={i->Int.toString} paymentOption=payOption isActive />
})
->React.array}
<TabLoader cardShimmerCount />
<RenderIf condition={dropDownOptionsDetails->Array.length > 0}>
<div className="flex relative h-auto justify-center">
<div className="flex flex-col items-center absolute mt-3 pointer-events-none gap-y-1.5">
{switch dropDownOptionsDetails->Array.get(moreIconIndex) {
| Some(paymentFieldsInfo) =>
switch paymentFieldsInfo.miniIcon {
| Some(ele) => displayIcon(ele)
| None =>
switch paymentFieldsInfo.icon {
| Some(ele) => displayIcon(ele)
| None => React.null
}
}
| None => React.null
}}
<Icon size=10 name="arrow-down" />
</div>
<select
value=selectedPaymentOption.paymentMethodName
ref={selectRef->ReactDOM.Ref.domRef}
className={`TabMore place-items-start outline-none`}
onChange=handleChange
disabled=readOnly
dataTestId=TestUtils.paymentMethodDropDownTestId
style={
width: "40px",
paddingLeft: themeObj.spacingUnit,
background: themeObj.colorBackground,
cursor: "pointer",
height: "inherit",
borderRadius: themeObj.borderRadius,
appearance: "none",
color: "transparent",
}>
<option value=selectedPaymentOption.paymentMethodName disabled={true}>
{React.string(
selectedPaymentOption.displayName === "Card"
? localeString.card
: {
let (name, _) = PaymentUtils.getDisplayNameAndIcon(
customMethodNames,
selectedPaymentOption.paymentMethodName,
selectedPaymentOption.displayName,
selectedPaymentOption.icon,
)
name
},
)}
</option>
{dropDownOptionsDetails
->Array.mapWithIndex((item, i) => {
<option
key={Int.toString(i)}
value=item.paymentMethodName
style={color: themeObj.colorPrimary}>
{React.string(
item.displayName === "card"
? localeString.card
: {
let (name, _) = PaymentUtils.getDisplayNameAndIcon(
customMethodNames,
item.paymentMethodName,
item.displayName,
item.icon,
)
name
},
)}
</option>
})
->React.array}
</select>
</div>
</RenderIf>
</div>
{checkoutEle}
</div>
}
| 1,591 | 10,337 |
hyperswitch-web
|
src/SoftTheme.res
|
.res
|
open CardThemeType
let soft = {
fontFamily: "Quicksand",
fontSizeBase: "1rem",
colorPrimary: "#7d8fff",
colorBackground: "#3c3d3e",
colorText: "#e0e0e0",
colorDanger: "#fe87a1",
colorDangerText: "#fe87a1",
borderRadius: "10px",
fontVariantLigatures: "",
fontVariationSettings: "",
spacingUnit: "11px",
fontWeightLight: "400",
fontWeightNormal: "500",
fontWeightMedium: "600",
fontWeightBold: "700",
fontLineHeight: "",
fontSize2Xl: "24px",
fontSizeXl: "16px",
fontSizeLg: "14px",
fontSizeSm: "12px",
fontSizeXs: "10px",
fontSize2Xs: "8px",
fontSize3Xs: "6px",
colorSuccess: "",
colorWarning: "",
colorPrimaryText: "#000000",
colorBackgroundText: "#ffffffe0",
colorSuccessText: "",
colorWarningText: "",
colorTextSecondary: "",
colorTextPlaceholder: "",
spacingTab: "15px",
borderColor: "#566186",
spacingAccordionItem: "10px",
colorIconCardCvc: "",
colorIconCardCvcError: "#fe87a1",
colorIconCardError: "#fe87a1",
spacingGridColumn: "20px",
spacingGridRow: "20px",
buttonBackgroundColor: "#3c3d3e",
buttonHeight: "48px",
buttonWidth: "100%",
buttonBorderRadius: "6px",
buttonBorderColor: "#7d8fff",
buttonTextColor: "#7d8fff",
buttonTextFontSize: "16px",
buttonTextFontWeight: "500",
buttonBorderWidth: "0px",
}
let softRules = theme =>
{
".Tab": {
"borderRadius": theme.borderRadius,
"alignItems": "start",
"padding": "12px 10px 9px 14px !important",
"color": theme.colorTextSecondary,
"transition": "background .15s ease, border .15s ease, box-shadow .15s ease",
"boxShadow": `4px 4px 5px #353637, -4px -4px 5px #434445`,
},
".Tab--selected": {
"color": theme.colorPrimary,
"background": "linear-gradient(340deg, #3d3d3d, #383838)",
"boxShadow": "inset 7px 8px 7px #353637, inset -5px -4px 7px #434445",
},
".TabMore": {
"boxShadow": `4px 4px 5px #353637, -4px -4px 5px #434445`,
},
".Tab--selected:hover": {
"boxShadow": "inset 7px 8px 7px #353637, inset -5px -4px 7px #434445",
},
".Tab--selected:focus": {
"borderColor": theme.colorPrimary,
"boxShadow": "inset 7px 8px 7px #353637, inset -5px -4px 7px #434445",
},
".Label": {
"color": theme.colorText,
"textAlign": "left",
},
".Input": {
"borderRadius": theme.borderRadius,
"color": theme.colorText,
"boxShadow": `inset 4px 4px 5px #353637, inset -4px -3px 7px #434445`,
"transition": "background 0.15s ease, border 0.15s ease, box-shadow 0.15s ease, color 0.15s ease",
},
".Input-Compressed": {
"color": theme.colorText,
"boxShadow": `inset 4px 4px 5px #353637, inset -4px -3px 7px #434445`,
"transition": "background 0.15s ease, border 0.15s ease, box-shadow 0.15s ease, color 0.15s ease",
},
".Input:-webkit-autofill": {
"transition": "background-color 5000s ease-in-out 0s",
"-webkitTextFillColor": `${theme.colorText} !important`,
},
".Input:focus": {
"boxShadow": `inset 8px 7px 7px #353637, inset -8px -6px 7px #434445`,
},
".Input-Compressed:focus": {
"boxShadow": `inset 8px 7px 7px #353637, inset -8px -6px 7px #434445`,
},
".Input--invalid": {
"color": theme.colorDanger,
},
".Input::placeholder": {
"fontWeight": theme.fontWeightLight,
"color": theme.colorTextPlaceholder,
},
".InputLogo": {
"color": "#979797",
},
".TabLabel": {
"transition": "color .1s ease",
"textAlign": "start",
},
".TabIcon": {
"transition": "color .1s ease",
},
".Block": {
"borderRadius": theme.borderRadius,
"color": theme.colorTextSecondary,
"transition": "background .15s ease, border .15s ease, box-shadow .15s ease",
"boxShadow": "inset 7px 8px 7px #353637, inset -5px -4px 7px #434445",
},
".BlockDivider": {
"borderRadius": theme.borderRadius,
"padding": "2px !important",
"color": theme.colorTextSecondary,
"transition": "background .15s ease, border .15s ease, box-shadow .15s ease",
"background": "#3d3d3d",
"boxShadow": `2px 2px 1px #353637, -2px -2px 1px #434445`,
"opacity": "80%",
},
".AccordionItem": {
"border": "1px solid transparent !important",
"margin": "3px",
"color": theme.colorTextSecondary,
"transition": "background .15s ease, border .15s ease, box-shadow .15s ease",
"boxShadow": `4px 4px 5px #353637, -4px -4px 5px #434445`,
"padding": "20px",
},
".AccordionItem--selected": {
"color": theme.colorPrimary,
"transition": "height 1s ease",
},
".AccordionItem--selected:hover": {
"boxShadow": "inset 7px 8px 7px #353637, inset -5px -4px 7px #434445",
},
".AccordionMore": {
"color": theme.colorTextSecondary,
"transition": "background .15s ease, border .15s ease, box-shadow .15s ease",
"boxShadow": `4px 4px 5px #353637, -4px -4px 5px #434445`,
"borderRadius": theme.borderRadius,
"color": theme.colorTextSecondary,
},
".AccordionMore:hover": {
"color": "#ffffff",
},
".AccordionItemLabel": {
"transition": "color .1s ease",
},
".AccordionItemLabel--selected": {
"color": theme.colorPrimary,
},
".AccordionItemIcon--selected": {
"color": theme.colorPrimary,
},
".PickerItem": {
"borderRadius": theme.borderRadius,
"color": theme.colorTextSecondary,
"margin": "5px",
"padding": theme.spacingUnit,
"transition": "background .15s ease, border .15s ease, box-shadow .15s ease",
"boxShadow": `4px 4px 5px #353637, -4px -4px 5px #434445`,
},
".PickerItem:hover": {
"color": "#ffffff",
},
".PickerItem--selected": {
"color": theme.colorPrimary,
"background": "linear-gradient(340deg, #3d3d3d, #383838)",
"boxShadow": "inset 7px 8px 7px #353637, inset -5px -4px 7px #434445",
},
".PickerItem--selected:hover": {
"color": theme.colorPrimary,
"boxShadow": "inset 7px 8px 7px #353637, inset -5px -4px 7px #434445",
},
".SavedItemLabel": {
"color": "white",
},
".Checkbox": {
"fontWeight": theme.fontWeightLight,
"fontSize": theme.fontSizeLg,
},
".PaymentMethodsHeaderLabel": {
"color": theme.colorText,
"fontSize": theme.fontSize2Xl,
"fontWeight": theme.fontWeightMedium,
"marginBottom": "1.5rem",
},
}->Identity.anyTypeToJson
let default = soft
let defaultRules = softRules
| 2,302 | 10,338 |
hyperswitch-web
|
src/CardUtils.res
|
.res
|
type cardIssuer =
| VISA
| MASTERCARD
| AMEX
| MAESTRO
| DINERSCLUB
| DISCOVER
| BAJAJ
| SODEXO
| RUPAY
| JCB
| CARTESBANCAIRES
| UNIONPAY
| INTERAC
| NOTFOUND
type cardProps = (
option<bool>,
(option<bool> => option<bool>) => unit,
option<bool>,
string,
JsxEvent.Form.t => unit,
JsxEvent.Focus.t => unit,
React.ref<Nullable.t<Dom.element>>,
React.element,
string,
(string => string) => unit,
int,
string,
)
type expiryProps = (
option<bool>,
(option<bool> => option<bool>) => unit,
string,
JsxEvent.Form.t => unit,
JsxEvent.Focus.t => unit,
React.ref<Nullable.t<Dom.element>>,
ReactEvent.Keyboard.t => unit,
string,
(string => string) => unit,
)
type cvcProps = (
option<bool>,
(option<bool> => option<bool>) => unit,
string,
(string => string) => unit,
JsxEvent.Form.t => unit,
JsxEvent.Focus.t => unit,
React.ref<Nullable.t<Dom.element>>,
ReactEvent.Keyboard.t => unit,
string,
(string => string) => unit,
)
type zipProps = (
option<bool>,
(option<bool> => option<bool>) => unit,
string,
ReactEvent.Form.t => unit,
ReactEvent.Focus.t => unit,
React.ref<Nullable.t<Dom.element>>,
ReactEvent.Keyboard.t => unit,
bool,
)
@val external document: 'a = "document"
@send external focus: Dom.element => unit = "focus"
@send external blur: Dom.element => unit = "blur"
type options = {timeZone: string}
type dateTimeFormat = {resolvedOptions: unit => options}
@val @scope("Intl") external dateTimeFormat: unit => dateTimeFormat = "DateTimeFormat"
let toInt = val => val->Int.fromString->Option.getOr(0)
let toString = val => val->Int.toString
let getQueryParamsDictforKey = (searchParams, keyName) => {
let dict = Dict.make()
searchParams
->String.split("&")
->Array.forEach(paramStr => {
let keyValArr = String.split(paramStr, "=")
let key = keyValArr->Array.get(0)->Option.getOr("")
let value = if keyValArr->Array.length > 0 {
keyValArr->Array.get(1)->Option.getOr("")
} else {
""
}
Dict.set(dict, key, value)
})
dict->Dict.get(keyName)->Option.getOr("")
}
let getCardType = val => {
switch val {
| "Visa" => VISA
| "Mastercard" => MASTERCARD
| "AmericanExpress" => AMEX
| "Maestro" => MAESTRO
| "DinersClub" => DINERSCLUB
| "Discover" => DISCOVER
| "BAJAJ" => BAJAJ
| "SODEXO" => SODEXO
| "RuPay" => RUPAY
| "JCB" => JCB
| "CartesBancaires" => CARTESBANCAIRES
| "UnionPay" => UNIONPAY
| "Interac" => INTERAC
| _ => NOTFOUND
}
}
let getCardStringFromType = val => {
switch val {
| VISA => "Visa"
| MASTERCARD => "Mastercard"
| AMEX => "AmericanExpress"
| MAESTRO => "Maestro"
| DINERSCLUB => "DinersClub"
| DISCOVER => "Discover"
| BAJAJ => "BAJAJ"
| SODEXO => "SODEXO"
| RUPAY => "RuPay"
| JCB => "JCB"
| CARTESBANCAIRES => "CartesBancaires"
| UNIONPAY => "UnionPay"
| INTERAC => "Interac"
| NOTFOUND => "NOTFOUND"
}
}
let getobjFromCardPattern = cardBrand => {
let patternsDict = CardPattern.cardPatterns
patternsDict
->Array.filter(item => {
cardBrand === item.issuer
})
->Array.get(0)
->Option.getOr(CardPattern.defaultCardPattern)
}
let clearSpaces = value => {
value->String.replaceRegExp(%re("/\D+/g"), "")
}
let slice = (val, start: int, end: int) => {
val->String.slice(~start, ~end)
}
let getStrFromIndex = (arr: array<string>, index) => {
arr->Array.get(index)->Option.getOr("")
}
let formatCVCNumber = (val, cardType) => {
let clearValue = val->clearSpaces
let obj = getobjFromCardPattern(cardType)
clearValue->slice(0, obj.maxCVCLength)
}
let getCurrentMonthAndYear = (dateTimeIsoString: string) => {
let tempTimeDateString = dateTimeIsoString->String.replace("Z", "")
let tempTimeDate = tempTimeDateString->String.split("T")
let date = tempTimeDate[0]->Option.getOr("")
let dateComponents = date->String.split("-")
let currentMonth = dateComponents->Array.get(1)->Option.getOr("")
let currentYear = dateComponents->Array.get(0)->Option.getOr("")
(currentMonth->toInt, currentYear->toInt)
}
let formatCardNumber = (val, cardType) => {
let clearValue = val->clearSpaces
let formatedCard = switch cardType {
| AMEX => `${clearValue->slice(0, 4)} ${clearValue->slice(4, 10)} ${clearValue->slice(10, 15)}`
| DINERSCLUB
| MASTERCARD
| DISCOVER
| SODEXO
| RUPAY
| UNIONPAY
| VISA =>
`${clearValue->slice(0, 4)} ${clearValue->slice(4, 8)} ${clearValue->slice(
8,
12,
)} ${clearValue->slice(12, 16)} ${clearValue->slice(16, 19)}`
| _ =>
`${clearValue->slice(0, 4)} ${clearValue->slice(4, 8)} ${clearValue->slice(
8,
12,
)} ${clearValue->slice(12, 19)}`
}
formatedCard->String.trim
}
let splitExpiryDates = val => {
let split = val->String.split("/")
let value = split->Array.map(item => item->String.trim)
let month = value->Array.get(0)->Option.getOr("")
let year = value->Array.get(1)->Option.getOr("")
(month, year)
}
let getExpiryDates = val => {
let date = Date.make()->Date.toISOString
let (month, year) = splitExpiryDates(val)
let (_, currentYear) = getCurrentMonthAndYear(date)
let prefix = currentYear->Int.toString->String.slice(~start=0, ~end=2)
(month, `${prefix}${year}`)
}
let formatExpiryToTwoDigit = expiry => {
if expiry->String.length == 2 {
expiry
} else {
expiry->String.slice(~start=2, ~end=4)
}
}
let isExpiryComplete = val => {
let (month, year) = splitExpiryDates(val)
month->String.length == 2 && year->String.length == 2
}
let formatCardExpiryNumber = val => {
let clearValue = val->clearSpaces
let expiryVal = clearValue->toInt
let formatted = if expiryVal >= 2 && expiryVal <= 9 && clearValue->String.length == 1 {
`0${clearValue} / `
} else if clearValue->String.length == 2 && expiryVal > 12 {
let val = clearValue->String.split("")
`0${val->getStrFromIndex(0)} / ${val->getStrFromIndex(1)}`
} else {
clearValue
}
if clearValue->String.length >= 3 {
`${formatted->slice(0, 2)} / ${formatted->slice(2, 4)}`
} else {
formatted
}
}
let getCardBrand = cardNumber => {
try {
let card = cardNumber->String.replaceRegExp(%re("/[^\d]/g"), "")
let rupayRanges = [
(508227, 508227),
(508500, 508999),
(603741, 603741),
(606985, 607384),
(607385, 607484),
(607485, 607984),
(608001, 608100),
(608101, 608200),
(608201, 608300),
(608301, 608350),
(608351, 608500),
(652150, 652849),
(652850, 653049),
(653050, 653149),
(817290, 817290),
]
let masterCardRanges = [(222100, 272099), (510000, 559999)]
let doesFallInRange = (cardRanges, isin) => {
let intIsin =
isin
->String.replaceRegExp(%re("/[^\d]/g"), "")
->String.substring(~start=0, ~end=6)
->Int.fromString
->Option.getOr(0)
let range = cardRanges->Array.map(cardRange => {
let (min, max) = cardRange
intIsin >= min && intIsin <= max
})
range->Array.includes(true)
}
let patternsDict = CardPattern.cardPatterns
if doesFallInRange(rupayRanges, card) {
"RuPay"
} else if doesFallInRange(masterCardRanges, card) {
"Mastercard"
} else {
patternsDict
->Array.map(item => {
if String.match(card, item.pattern)->Option.isSome {
item.issuer
} else {
""
}
})
->Array.filter(item => item !== "")
->Array.get(0)
->Option.getOr("")
}
} catch {
| _error => ""
}
}
let calculateLuhn = value => {
let card = value->clearSpaces
let splitArr = card->String.split("")
splitArr->Array.reverse
let unCheckArr = splitArr->Array.filterWithIndex((_, i) => {
mod(i, 2) == 0
})
let checkArr =
splitArr
->Array.filterWithIndex((_, i) => {
mod(i + 1, 2) == 0
})
->Array.map(item => {
let val = item->toInt
let double = val * 2
let str = double->Int.toString
let arr = str->String.split("")
switch (arr[0], arr[1]) {
| (Some(first), Some(second)) if double > 9 => (first->toInt + second->toInt)->Int.toString
| _ => str
}
})
let sumofCheckArr = Array.reduce(checkArr, 0, (acc, val) => acc + val->toInt)
let sumofUnCheckedArr = Array.reduce(unCheckArr, 0, (acc, val) => acc + val->toInt)
let totalSum = sumofCheckArr + sumofUnCheckedArr
mod(totalSum, 10) == 0 || ["3000100811111072", "4000100511112003"]->Array.includes(card) // test cards
}
let getCardBrandIcon = (cardType, paymentType) => {
open CardThemeType
open Utils
switch cardType {
| VISA => <Icon size=brandIconSize name="visa-light" />
| MASTERCARD => <Icon size=brandIconSize name="mastercard" />
| AMEX => <Icon size=brandIconSize name="amex-light" />
| MAESTRO => <Icon size=brandIconSize name="maestro" />
| DINERSCLUB => <Icon size=brandIconSize name="diners" />
| DISCOVER => <Icon size=brandIconSize name="discover" />
| BAJAJ => <Icon size=brandIconSize name="card" />
| SODEXO => <Icon size=brandIconSize name="card" />
| RUPAY => <Icon size=brandIconSize name="rupay-card" />
| JCB => <Icon size=brandIconSize name="jcb-card" />
| CARTESBANCAIRES => <Icon size=brandIconSize name="cartesbancaires-card" />
| UNIONPAY => <Icon size=brandIconSize name="union-pay" />
| INTERAC => <Icon size=brandIconSize name="interac" />
| NOTFOUND =>
switch paymentType {
| Payment => <Icon size=brandIconSize name="base-card" />
| Card
| CardNumberElement
| CardExpiryElement
| CardCVCElement
| PaymentMethodCollectElement
| GooglePayElement
| PayPalElement
| ApplePayElement
| SamsungPayElement
| KlarnaElement
| ExpressCheckoutElement
| PaymentMethodsManagement
| PazeElement
| NONE =>
<Icon size=brandIconSize name="default-card" />
}
}
}
let getExpiryValidity = cardExpiry => {
let date = Date.make()->Date.toISOString
let (month, year) = getExpiryDates(cardExpiry)
let (currentMonth, currentYear) = getCurrentMonthAndYear(date)
let valid = if currentYear == year->toInt && month->toInt >= currentMonth && month->toInt <= 12 {
true
} else if (
year->toInt > currentYear &&
year->toInt < Date.getFullYear(Js.Date.fromFloat(Date.now())) + 100 &&
month->toInt >= 1 &&
month->toInt <= 12
) {
true
} else {
false
}
valid
}
let isExipryValid = val => {
val->String.length > 0 && getExpiryValidity(val) && isExpiryComplete(val)
}
let cardNumberInRange = val => {
let clearValue = val->clearSpaces
let obj = getobjFromCardPattern(val->getCardBrand)
let cardLengthInRange = obj.length->Array.map(item => {
clearValue->String.length == item
})
cardLengthInRange
}
let max = (a, b) => {
Math.Int.max(a, b)
}
let getMaxLength = val => {
let obj = getobjFromCardPattern(val->getCardBrand)
let maxValue = obj.length->Array.reduce(0, max)
if maxValue <= 12 {
maxValue + 2
} else if maxValue <= 16 {
maxValue + 3
} else if maxValue <= 19 {
maxValue + 4
} else {
maxValue + 2
}
}
let cvcNumberInRange = (val, cardBrand) => {
let clearValue = val->clearSpaces
let obj = getobjFromCardPattern(cardBrand)
let cvcLengthInRange = obj.cvcLength->Array.map(item => {
clearValue->String.length == item
})
cvcLengthInRange
}
let generateFontsLink = (fonts: array<CardThemeType.fonts>) => {
if fonts->Array.length > 0 {
fonts
->Array.map(item =>
if item.cssSrc != "" {
let link = document["createElement"]("link")
link["href"] = item.cssSrc
link["rel"] = "stylesheet"
document["body"]["appendChild"](link)
} else if item.family != "" && item.src != "" {
let newStyle = document["createElement"]("style")
newStyle["appendChild"](
document["createTextNode"](
`\
@font-face {\
font-family: "${item.family}";\
src: url(${item.src});\
font-weight: "${item.weight}";\
}\
`,
),
)->ignore
document["body"]["appendChild"](newStyle)
}
)
->ignore
}
}
let maxCardLength = cardBrand => {
let obj = getobjFromCardPattern(cardBrand)
Array.reduce(obj.length, 0, (acc, val) => max(acc, val))
}
let isCardLengthValid = (cardBrand, cardNumberLength) => {
let obj = getobjFromCardPattern(cardBrand)
Array.includes(obj.length, cardNumberLength)
}
let cardValid = (cardNumber, cardBrand) => {
let clearValueLength = cardNumber->clearSpaces->String.length
isCardLengthValid(cardBrand, clearValueLength) && calculateLuhn(cardNumber)
}
let focusCardValid = (cardNumber, cardBrand) => {
let clearValueLength = cardNumber->clearSpaces->String.length
if cardBrand == "" {
clearValueLength == maxCardLength(cardBrand) && calculateLuhn(cardNumber)
} else {
(clearValueLength == maxCardLength(cardBrand) ||
(cardBrand === "Visa" && clearValueLength == 16)) && calculateLuhn(cardNumber)
}
}
let blurRef = (ref: React.ref<Nullable.t<Dom.element>>) => {
ref.current->Nullable.toOption->Option.forEach(input => input->blur)->ignore
}
let focusRef = (ref: React.ref<Nullable.t<Dom.element>>) => {
ref.current->Nullable.toOption->Option.forEach(input => input->focus)->ignore
}
let handleInputFocus = (
~currentRef: React.ref<Nullable.t<Dom.element>>,
~destinationRef: React.ref<Nullable.t<Dom.element>>,
) => {
let optionalRef = destinationRef.current->Nullable.toOption
switch optionalRef {
| Some(_) => optionalRef->Option.forEach(input => input->focus)->ignore
| None => blurRef(currentRef)
}
}
let getCardElementValue = (iframeId, key) => {
let firstIframeVal = if (Window.parent->Window.frames)["0"]->Window.name !== iframeId {
switch (Window.parent->Window.frames)["0"]
->Window.document
->Window.getElementById(key)
->Nullable.toOption {
| Some(dom) => dom->Window.value
| None => ""
}
} else {
""
}
let secondIframeVal = if (Window.parent->Window.frames)["1"]->Window.name !== iframeId {
switch (Window.parent->Window.frames)["1"]
->Window.document
->Window.getElementById(key)
->Nullable.toOption {
| Some(dom) => dom->Window.value
| None => ""
}
} else {
""
}
let thirdIframeVal = if (Window.parent->Window.frames)["2"]->Window.name !== iframeId {
switch (Window.parent->Window.frames)["2"]
->Window.document
->Window.getElementById(key)
->Nullable.toOption {
| Some(dom) => dom->Window.value
| None => ""
}
} else {
""
}
thirdIframeVal === "" ? secondIframeVal === "" ? firstIframeVal : secondIframeVal : thirdIframeVal
}
let checkCardCVC = (cvcNumber, cardBrand) => {
cvcNumber->String.length > 0 && cvcNumberInRange(cvcNumber, cardBrand)->Array.includes(true)
}
let checkCardExpiry = expiry => {
expiry->String.length > 0 && getExpiryValidity(expiry)
}
let getBoolOptionVal = boolOptionVal => {
switch boolOptionVal {
| Some(bool) => bool ? "valid" : "invalid"
| None => ""
}
}
let commonKeyDownEvent = (ev, srcRef, destRef, srcEle, destEle, setEle) => {
let key = ReactEvent.Keyboard.keyCode(ev)
if key == 8 && srcEle == "" {
handleInputFocus(~currentRef=srcRef, ~destinationRef=destRef)
setEle(_ => slice(destEle, 0, -1))
ev->ReactEvent.Keyboard.preventDefault
}
}
let pincodeVisibility = cardNumber => {
let brand = getCardBrand(cardNumber)
let brandPattern =
CardPattern.cardPatterns
->Array.filter(obj => obj.issuer == brand)
->Array.get(0)
->Option.getOr(CardPattern.defaultCardPattern)
brandPattern.pincodeRequired
}
let swapCardOption = (cardOpts: array<string>, dropOpts: array<string>, selectedOption: string) => {
let popEle = Array.pop(cardOpts)
dropOpts->Array.push(popEle->Option.getOr(""))->ignore
cardOpts->Array.push(selectedOption)->ignore
let temp: array<string> = dropOpts->Array.filter(item => item != selectedOption)
(cardOpts, temp)
}
let setCardValid = (cardnumber, setIsCardValid) => {
let cardBrand = getCardBrand(cardnumber)
let isCardMaxLength = cardnumber->String.length == maxCardLength(cardBrand)
if cardValid(cardnumber, cardBrand) {
setIsCardValid(_ => Some(true))
} else if !cardValid(cardnumber, cardBrand) && isCardMaxLength {
setIsCardValid(_ => Some(false))
} else if !isCardMaxLength {
setIsCardValid(_ => None)
}
}
let setExpiryValid = (expiry, setIsExpiryValid) => {
if isExipryValid(expiry) {
setIsExpiryValid(_ => Some(true))
} else if !getExpiryValidity(expiry) && isExpiryComplete(expiry) {
setIsExpiryValid(_ => Some(false))
} else if !isExpiryComplete(expiry) {
setIsExpiryValid(_ => None)
}
}
let getLayoutClass = layout => {
open PaymentType
switch layout {
| ObjectLayout(obj) => obj
| StringLayout(str) => {
...defaultLayout,
\"type": str,
}
}
}
let getAllBanknames = obj => {
obj->Array.reduce([], (acc, item) => {
item->Array.map(val => acc->Array.push(val))->ignore
acc
})
}
let clientTimeZone = dateTimeFormat().resolvedOptions().timeZone
let clientCountry = Utils.getClientCountry(clientTimeZone)
let postalRegex = (postalCodes: array<PostalCodeType.postalCodes>, ~country=?) => {
let country = country->Option.getOr(clientCountry.isoAlpha2)
let countryPostal = Utils.getCountryPostal(country, postalCodes)
countryPostal.regex
}
let setRightIconForCvc = (~cardEmpty, ~cardInvalid, ~color, ~cardComplete) => {
open Utils
if cardEmpty {
<Icon size=brandIconSize name="cvc-empty" />
} else if cardInvalid {
<div style={color: color}>
<Icon size=brandIconSize name="cvc-invalid" />
</div>
} else if cardComplete {
<Icon size=brandIconSize name="cvc-complete" />
} else {
<Icon size=brandIconSize name="cvc-empty" />
}
}
let useCardDetails = (~cvcNumber, ~isCvcValidValue, ~isCVCValid) => {
React.useMemo(() => {
let isCardDetailsEmpty = String.length(cvcNumber) == 0
let isCardDetailsValid = isCvcValidValue == "valid"
let isCardDetailsInvalid = isCvcValidValue == "invalid"
(isCardDetailsEmpty, isCardDetailsValid, isCardDetailsInvalid)
}, (cvcNumber, isCvcValidValue, isCVCValid))
}
let getWalletBrandIcon = (customerMethod: PaymentType.customerMethods) => {
let iconName = switch customerMethod.paymentMethodType {
| Some("apple_pay") => "apple_pay_saved"
| Some("google_pay") => "google_pay_saved"
| Some("samsung_pay") => "samsung_pay_saved"
| Some("paypal") => "paypal"
| _ => "default-card"
}
<Icon size=Utils.brandIconSize name=iconName />
}
let getPaymentMethodBrand = (customerMethod: PaymentType.customerMethods) => {
switch customerMethod.paymentMethod {
| "wallet" => getWalletBrandIcon(customerMethod)
| _ =>
getCardBrandIcon(
switch customerMethod.card.scheme {
| Some(ele) => ele
| None => ""
}->getCardType,
""->CardThemeType.getPaymentMode,
)
}
}
let getAllMatchedCardSchemes = cardNumber => {
CardPattern.cardPatterns->Array.reduce([], (acc, item) => {
if String.match(cardNumber, item.pattern)->Option.isSome {
acc->Array.push(item.issuer)
}
acc
})
}
let getEligibleCoBadgedCardSchemes = (~matchedCardSchemes, ~enabledCardSchemes) => {
matchedCardSchemes->Array.filter(ele => {
enabledCardSchemes->Array.includes(ele->String.toLowerCase)
})
}
let getCardBrandFromStates = (cardBrand, cardScheme, showFields) => {
!showFields ? cardScheme : cardBrand
}
let getCardBrandInvalidError = (~cardNumber, ~localeString: LocaleStringTypes.localeStrings) => {
switch cardNumber->getCardBrand {
| "" => localeString.enterValidCardNumberErrorText
| cardBrandValue => localeString.cardBrandConfiguredErrorText(cardBrandValue)
}
}
let emitExpiryDate = formattedExpiry =>
Utils.messageParentWindow([("expiryDate", formattedExpiry->JSON.Encode.string)])
let emitIsFormReadyForSubmission = isFormReadyForSubmission =>
Utils.messageParentWindow([
("isFormReadyForSubmission", isFormReadyForSubmission->JSON.Encode.bool),
])
| 5,983 | 10,339 |
hyperswitch-web
|
src/DefaultTheme.res
|
.res
|
open CardThemeType
let default = {
fontFamily: "",
fontSizeBase: "1rem",
colorPrimary: "#006df9",
colorBackground: "#ffffff",
colorText: "#545454",
colorDanger: "#fd1717",
colorDangerText: "#fd1717",
borderRadius: "4px",
fontVariantLigatures: "",
fontVariationSettings: "",
spacingUnit: "11px",
fontWeightLight: "400",
fontWeightNormal: "500",
fontWeightMedium: "600",
fontWeightBold: "700",
fontLineHeight: "",
fontSize2Xl: "24px",
fontSizeXl: "16px",
fontSizeLg: "14px",
fontSizeSm: "12px",
fontSizeXs: "10px",
fontSize2Xs: "8px",
fontSize3Xs: "6px",
colorSuccess: "",
colorWarning: "",
colorPrimaryText: "#5469d4",
colorBackgroundText: "",
colorSuccessText: "",
colorWarningText: "",
colorTextSecondary: "#6d6e78",
colorTextPlaceholder: "",
spacingTab: "12px",
borderColor: "#e6e6e6",
spacingAccordionItem: "10px",
colorIconCardCvc: "",
colorIconCardCvcError: "#fd1717",
colorIconCardError: "#fd1717",
spacingGridColumn: "20px",
spacingGridRow: "20px",
buttonBackgroundColor: "#006df9",
buttonHeight: "48px",
buttonWidth: "100%",
buttonBorderRadius: "6px",
buttonBorderColor: "#ffffff",
buttonTextColor: "#ffffff",
buttonTextFontSize: "16px",
buttonTextFontWeight: "500",
buttonBorderWidth: "0px",
}
let defaultRules = theme =>
{
".Tab": {
"border": `1px solid ${theme.borderColor}`,
"borderRadius": theme.borderRadius,
"backgroundColor": theme.colorBackground,
"color": theme.colorTextSecondary,
"alignItems": "start",
"transition": "background .15s ease, border .15s ease, box-shadow .15s ease",
"boxShadow": "0px 1px 1px rgb(0 0 0 / 3%), 0px 3px 6px rgb(0 0 0 / 2%)",
},
".Tab:hover": {
"color": theme.colorText,
},
".Label": {
"color": theme.colorText,
"opacity": "10",
"textAlign": "left",
},
".Tab--selected": {
"color": theme.colorPrimary,
"boxShadow": `0px 1px 1px rgba(0, 0, 0, 0.03), 0px 3px 6px rgba(18, 42, 66, 0.02), 0 0 0 2px ${theme.colorPrimary}`,
},
".Tab--selected:hover": {
"border": `1px solid ${theme.colorPrimary}`,
"color": theme.colorPrimary,
"boxShadow": `0px 1px 1px rgba(0, 0, 0, 0.03), 0px 3px 6px rgba(18, 42, 66, 0.02), 0 0 0 2px ${theme.colorPrimary}`,
},
".Tab--selected:focus": {
"border": `2px solid ${theme.colorPrimary}`,
"borderColor": theme.colorPrimary,
"boxShadow": `0 0 0 2px ${theme.colorPrimary}4c, 0 1px 1px 0 ${theme.colorBackground}, 0 0 0 1px ${theme.colorPrimary}4c`,
},
".TabMore:focus": {
"border": `1px solid ${theme.colorPrimary}`,
"boxShadow": `${theme.colorPrimary}4c 0px 0px 0px 3px`,
},
".TabMore": {
"border": `1px solid ${theme.borderColor}`,
},
".Input": {
"border": `1px solid #e6e6e6`,
"color": theme.colorText,
"fontWeight": theme.fontWeightLight,
"borderRadius": theme.borderRadius,
"boxShadow": `0px 1px 1px rgb(0 0 0 / 3%), 0px 3px 6px rgb(0 0 0 / 2%)`,
"transition": "background 0.15s ease, border 0.15s ease, box-shadow 0.15s ease, color 0.15s ease",
},
".Input-Compressed": {
"border": `1px solid #e6e6e6`,
"color": theme.colorText,
"fontWeight": theme.fontWeightLight,
"boxShadow": `0px 1px 1px rgb(0 0 0 / 3%), 0px 3px 6px rgb(0 0 0 / 2%)`,
"transition": "background 0.15s ease, border 0.15s ease, box-shadow 0.15s ease, color 0.15s ease",
},
".Input:-webkit-autofill": {
"transition": "background-color 5000s ease-in-out 0s",
"-webkitTextFillColor": `${theme.colorText} !important`,
},
".Input:focus": {
"border": `1px solid ${theme.colorPrimary}`,
"boxShadow": `${theme.colorPrimary}4c 0px 0px 0px 3px`,
},
".Input-Compressed:focus": {
"border": `1px solid ${theme.colorPrimary}`,
"boxShadow": `${theme.colorPrimary}4c 0px 0px 0px 2px`,
"position": "relative",
"zIndex": "2",
},
".Input--invalid": {
"color": theme.colorDanger,
"border": `1px solid ${theme.colorDanger}`,
"transition": "border 0.15s ease, box-shadow 0.15s ease, color 0.15s ease",
},
".Input::placeholder": {
"fontWeight": theme.fontWeightLight,
"color": theme.colorTextPlaceholder,
},
".InputLogo": {
"color": "#979797",
},
".TabLabel": {
"transition": "color .1s ease",
"textAlign": "start",
},
".TabIcon": {
"transition": "color .1s ease",
},
".Block": {
"backgroundColor": theme.colorBackground,
"borderRadius": theme.borderRadius,
"border": `1px solid ${theme.borderColor}`,
},
".BlockDivider": {
"border": `1px solid ${theme.borderColor}`,
},
".AccordionItem": {
"backgroundColor": theme.colorBackground,
"color": theme.colorTextSecondary,
"transition": "height 1s ease",
"boxShadow": "0px 1px 1px rgb(0 0 0 / 3%), 0px 3px 6px rgb(0 0 0 / 2%)",
"padding": "20px",
},
".AccordionMore": {
"backgroundColor": theme.colorBackground,
"color": theme.colorTextSecondary,
"border": `1px solid ${theme.borderColor}`,
},
".AccordionMore:hover": {
"color": theme.colorText,
},
".AccordionItem:hover": {
"color": theme.colorText,
},
".AccordionItem--selected": {
"color": theme.colorPrimary,
},
".AccordionItem--selected:hover": {
"color": theme.colorPrimary,
},
".AccordionItemLabel": {
"transition": "color .1s ease",
},
".AccordionItemLabel--selected": {
"color": theme.colorPrimary,
},
".AccordionItemIcon--selected": {
"color": theme.colorPrimary,
},
".PickerItem": {
"backgroundColor": theme.colorBackground,
"borderRadius": theme.borderRadius,
"border": `1px solid ${theme.borderColor}`,
"color": theme.colorTextSecondary,
"padding": theme.spacingUnit,
"transition": "height 1s ease",
"boxShadow": "0px 1px 1px rgb(0 0 0 / 3%), 0px 3px 6px rgb(0 0 0 / 2%)",
},
".PickerItem:hover": {
"color": theme.colorText,
},
".PickerItem--selected": {
"color": theme.colorPrimary,
"border": `1px solid ${theme.colorPrimary}`,
"boxShadow": `${theme.colorPrimary}4c 0px 0px 0px 3px`,
},
".PickerItem--selected:hover": {
"color": theme.colorPrimary,
"border": `1px solid ${theme.colorPrimary}`,
"boxShadow": `${theme.colorPrimary}4c 0px 0px 0px 3px`,
},
".Checkbox": {
"fontWeight": theme.fontWeightLight,
"fontSize": theme.fontSizeLg,
},
".PaymentMethodsHeaderLabel": {
"color": theme.colorText,
"fontSize": theme.fontSize2Xl,
"fontWeight": theme.fontWeightMedium,
"marginBottom": "1.5rem",
},
}->Identity.anyTypeToJson
let default = default
let defaultRules = defaultRules
| 2,194 | 10,340 |
hyperswitch-web
|
src/BrowserSpec.res
|
.res
|
type navigator = {
userAgent: string,
language: string,
}
type date = {getTimezoneOffset: unit => float}
type screen = {colorDepth: int, height: int, width: int}
@val external navigator: navigator = "navigator"
@val external screen: screen = "screen"
@new external date: unit => date = "Date"
let checkIsSafari = () => {
let userAgentString = navigator.userAgent
let chromeAgent = userAgentString->String.indexOf("Chrome") > -1
let safariAgent = userAgentString->String.indexOf("Safari") > -1
!chromeAgent && safariAgent
}
let date = date()
let broswerInfo = () => {
let data = UAParser.make()
let osType = data.os.name->Option.getOr("Unknown")
let osVersion = data.os.version->Option.getOr("Unknown")
let deviceModel = data.device.model->Option.getOr("Unknown Device")
let colorDepth =
[1, 4, 8, 15, 16, 24, 32, 48]->Array.includes(screen.colorDepth) ? screen.colorDepth : 24
[
(
"browser_info",
[
("user_agent", navigator.userAgent->JSON.Encode.string),
(
"accept_header",
"text\/html,application\/xhtml+xml,application\/xml;q=0.9,image\/webp,image\/apng,*\/*;q=0.8"->JSON.Encode.string,
),
("language", navigator.language->JSON.Encode.string),
("color_depth", colorDepth->Int.toFloat->JSON.Encode.float),
("screen_height", screen.height->Int.toFloat->JSON.Encode.float),
("screen_width", screen.width->Int.toFloat->JSON.Encode.float),
("time_zone", date.getTimezoneOffset()->JSON.Encode.float),
("java_enabled", true->JSON.Encode.bool),
("java_script_enabled", true->JSON.Encode.bool),
("device_model", deviceModel->JSON.Encode.string),
("os_type", osType->JSON.Encode.string),
("os_version", osVersion->JSON.Encode.string),
]->Utils.getJsonFromArrayOfJson,
),
]
}
| 472 | 10,341 |
hyperswitch-web
|
src/PaymentElement.res
|
.res
|
open PaymentType
open Utils
let cardsToRender = (width: int) => {
let minWidth = 130
let noOfCards = (width - 40) / minWidth
noOfCards
}
@react.component
let make = (~cardProps, ~expiryProps, ~cvcProps, ~paymentType: CardThemeType.mode) => {
let divRef = React.useRef(Nullable.null)
let sessionsObj = Recoil.useRecoilValueFromAtom(RecoilAtoms.sessions)
let {
showCardFormByDefault,
paymentMethodOrder,
layout,
customerPaymentMethods,
displaySavedPaymentMethods,
sdkHandleConfirmPayment,
} = Recoil.useRecoilValueFromAtom(RecoilAtoms.optionAtom)
let {themeObj, localeString} = Recoil.useRecoilValueFromAtom(RecoilAtoms.configAtom)
let optionAtomValue = Recoil.useRecoilValueFromAtom(RecoilAtoms.optionAtom)
let paymentMethodList = Recoil.useRecoilValueFromAtom(RecoilAtoms.paymentMethodList)
let isApplePayReady = Recoil.useRecoilValueFromAtom(RecoilAtoms.isApplePayReady)
let isGPayReady = Recoil.useRecoilValueFromAtom(RecoilAtoms.isGooglePayReady)
let {publishableKey} = Recoil.useRecoilValueFromAtom(RecoilAtoms.keys)
let loggerState = Recoil.useRecoilValueFromAtom(RecoilAtoms.loggerAtom)
let isShowOrPayUsing = Recoil.useRecoilValueFromAtom(RecoilAtoms.isShowOrPayUsing)
let (clickToPayConfig, setClickToPayConfig) = Recoil.useRecoilState(RecoilAtoms.clickToPayConfig)
let (selectedOption, setSelectedOption) = Recoil.useRecoilState(RecoilAtoms.selectedOptionAtom)
let (showFields, setShowFields) = Recoil.useRecoilState(RecoilAtoms.showCardFieldsAtom)
let (paymentToken, setPaymentToken) = Recoil.useRecoilState(RecoilAtoms.paymentTokenAtom)
let (paymentMethodListValue, setPaymentMethodListValue) = Recoil.useRecoilState(
PaymentUtils.paymentMethodListValue,
)
let (sessions, setSessions) = React.useState(_ => Dict.make()->JSON.Encode.object)
let (paymentOptions, setPaymentOptions) = React.useState(_ => [])
let (walletOptions, setWalletOptions) = React.useState(_ => [])
let (cardsContainerWidth, setCardsContainerWidth) = React.useState(_ => 0)
let (dropDownOptions: array<string>, setDropDownOptions) = React.useState(_ => [])
let (cardOptions: array<string>, setCardOptions) = React.useState(_ => [])
let (savedMethods, setSavedMethods) = React.useState(_ => [])
let (
loadSavedCards: savedCardsLoadState,
setLoadSavedCards: (savedCardsLoadState => savedCardsLoadState) => unit,
) = React.useState(_ => LoadingSavedCards)
let (isClickToPayAuthenticateError, setIsClickToPayAuthenticateError) = React.useState(_ => false)
let (areClickToPayUIScriptsLoaded, setAreClickToPayUIScriptsLoaded) = React.useState(_ => false)
let isShowPaymentMethodsDependingOnClickToPay = React.useMemo(() => {
(clickToPayConfig.clickToPayCards->Option.getOr([])->Array.length > 0 ||
clickToPayConfig.isReady->Option.getOr(false) &&
clickToPayConfig.clickToPayCards->Option.isNone ||
clickToPayConfig.email !== "") && !isClickToPayAuthenticateError
}, (clickToPayConfig, isClickToPayAuthenticateError))
let layoutClass = CardUtils.getLayoutClass(layout)
React.useEffect(() => {
switch (displaySavedPaymentMethods, customerPaymentMethods) {
| (false, _) => {
setShowFields(_ => isShowPaymentMethodsDependingOnClickToPay->not)
setLoadSavedCards(_ => LoadedSavedCards([], true))
}
| (_, LoadingSavedCards) => ()
| (_, LoadedSavedCards(savedPaymentMethods, isGuestCustomer)) => {
let displayDefaultSavedPaymentIcon = optionAtomValue.displayDefaultSavedPaymentIcon
let sortSavedPaymentMethods = (a, b) => {
let defaultCompareVal = compareLogic(
Date.fromString(a.lastUsedAt),
Date.fromString(b.lastUsedAt),
)
if displayDefaultSavedPaymentIcon {
if a.defaultPaymentMethodSet {
-1.
} else if b.defaultPaymentMethodSet {
1.
} else {
defaultCompareVal
}
} else {
defaultCompareVal
}
}
let finalSavedPaymentMethods =
savedPaymentMethods
->Array.copy
->Array.filter(savedMethod => {
switch savedMethod.paymentMethodType {
| Some("apple_pay") => isApplePayReady
| Some("google_pay") => isGPayReady
| _ => true
}
})
finalSavedPaymentMethods->Array.sort(sortSavedPaymentMethods)
let paymentOrder = paymentMethodOrder->getOptionalArr->removeDuplicate
let sortSavedMethodsBasedOnPriority =
finalSavedPaymentMethods->PaymentUtils.sortCustomerMethodsBasedOnPriority(
paymentOrder,
~displayDefaultSavedPaymentIcon,
)
setSavedMethods(_ => sortSavedMethodsBasedOnPriority)
setLoadSavedCards(_ =>
finalSavedPaymentMethods->Array.length == 0
? NoResult(isGuestCustomer)
: LoadedSavedCards(finalSavedPaymentMethods, isGuestCustomer)
)
setShowFields(_ =>
finalSavedPaymentMethods->Array.length == 0 &&
isShowPaymentMethodsDependingOnClickToPay->not
)
}
| (_, NoResult(isGuestCustomer)) => {
setLoadSavedCards(_ => NoResult(isGuestCustomer))
setShowFields(_ => true && isShowPaymentMethodsDependingOnClickToPay->not)
}
}
None
}, (
customerPaymentMethods,
displaySavedPaymentMethods,
optionAtomValue,
isApplePayReady,
isGPayReady,
clickToPayConfig.isReady,
isShowPaymentMethodsDependingOnClickToPay,
))
React.useEffect(() => {
let defaultSelectedPaymentMethod = optionAtomValue.displayDefaultSavedPaymentIcon
? savedMethods->Array.find(savedMethod => savedMethod.defaultPaymentMethodSet)
: savedMethods->Array.get(0)
let isSavedMethodsEmpty = savedMethods->Array.length === 0
let tokenObj = switch (isSavedMethodsEmpty, defaultSelectedPaymentMethod) {
| (false, Some(defaultSelectedPaymentMethod)) => Some(defaultSelectedPaymentMethod)
| (false, None) => Some(savedMethods->Array.get(0)->Option.getOr(defaultCustomerMethods))
| _ => None
}
switch tokenObj {
| Some(obj) =>
setPaymentToken(_ => {
paymentToken: obj.paymentToken,
customerId: obj.customerId,
})
| None => ()
}
None
}, [savedMethods])
let (walletList, paymentOptionsList, actualList) = PaymentUtils.useGetPaymentMethodList(
~paymentOptions,
~paymentType,
~sessions,
)
let dict = sessions->getDictFromJson
let sessionObj = SessionsType.itemToObjMapper(dict, Others)
let applePaySessionObj = SessionsType.itemToObjMapper(dict, ApplePayObject)
let applePayToken = SessionsType.getPaymentSessionObj(applePaySessionObj.sessionsToken, ApplePay)
let gPayToken = SessionsType.getPaymentSessionObj(sessionObj.sessionsToken, Gpay)
let googlePayThirdPartySessionObj = SessionsType.itemToObjMapper(dict, GooglePayThirdPartyObject)
let googlePayThirdPartyToken = SessionsType.getPaymentSessionObj(
googlePayThirdPartySessionObj.sessionsToken,
Gpay,
)
let {
paypalToken,
isPaypalSDKFlow,
isPaypalRedirectFlow,
} = PayPalHelpers.usePaymentMethodExperience(~paymentMethodListValue, ~sessionObj)
React.useEffect(() => {
switch paymentMethodList {
| Loaded(paymentlist) =>
let plist = paymentlist->getDictFromJson->PaymentMethodsRecord.itemToObjMapper
setPaymentOptions(_ =>
[
...showCardFormByDefault && checkPriorityList(paymentMethodOrder) ? ["card"] : [],
...paymentOptionsList,
]->removeDuplicate
)
setWalletOptions(_ => walletList)
setPaymentMethodListValue(_ => plist)
showCardFormByDefault
? if !(actualList->Array.includes(selectedOption)) && selectedOption !== "" {
ErrorUtils.manageErrorWarning(
SDK_CONNECTOR_WARNING,
~dynamicStr="Please enable Card Payment in the dashboard, or 'ShowCard.FormByDefault' to false.",
~logger=loggerState,
)
} else if !checkPriorityList(paymentMethodOrder) {
ErrorUtils.manageErrorWarning(
SDK_CONNECTOR_WARNING,
~dynamicStr=`'paymentMethodOrder' is ${Array.joinWith(
paymentMethodOrder->getOptionalArr,
", ",
)} . Please enable Card Payment as 1st priority to show it as default.`,
~logger=loggerState,
)
}
: ()
| LoadError(_)
| SemiLoaded =>
setPaymentOptions(_ =>
showCardFormByDefault && checkPriorityList(paymentMethodOrder) ? ["card"] : []
)
| _ => ()
}
None
}, (paymentMethodList, walletList, paymentOptionsList, actualList, showCardFormByDefault))
let loadMastercardClickToPayScript = ssn => {
open Promise
let dict = ssn->getDictFromJson
let clickToPaySessionObj = SessionsType.itemToObjMapper(dict, ClickToPayObject)
let clickToPayToken = SessionsType.getPaymentSessionObj(
clickToPaySessionObj.sessionsToken,
ClickToPay,
)
switch clickToPayToken {
| ClickToPayTokenOptional(optToken) =>
switch optToken {
| Some(token) =>
let clickToPayToken = ClickToPayHelpers.clickToPayTokenItemToObjMapper(token)
let isProd = publishableKey->String.startsWith("pk_prd_")
ClickToPayHelpers.loadClickToPayScripts(loggerState)
->then(_ => {
setAreClickToPayUIScriptsLoaded(_ => true)
resolve()
})
->catch(_ => {
loggerState.setLogError(
~value="ClickToPay UI Kit CSS Load Error",
~eventName=CLICK_TO_PAY_SCRIPT,
)
resolve()
})
->ignore
ClickToPayHelpers.loadMastercardScript(clickToPayToken, isProd, loggerState)
->then(resp => {
let availableCardBrands =
resp
->Utils.getDictFromJson
->Utils.getArray("availableCardBrands")
->Array.map(item => item->JSON.Decode.string->Option.getOr(""))
->Array.filter(item => item !== "")
setClickToPayConfig(prev => {
...prev,
isReady: Some(true),
availableCardBrands,
email: clickToPayToken.email,
dpaName: clickToPayToken.dpaName,
})
resolve()
})
->catch(_ => {
setClickToPayConfig(prev => {
...prev,
isReady: Some(false),
})
resolve()
})
->ignore
| None =>
setClickToPayConfig(prev => {
...prev,
isReady: Some(false),
})
}
| _ =>
setClickToPayConfig(prev => {
...prev,
isReady: Some(false),
})
}
}
React.useEffect(() => {
switch sessionsObj {
| Loaded(ssn) => {
setSessions(_ => ssn)
loadMastercardClickToPayScript(ssn)
}
| _ => ()
}
None
}, [sessionsObj])
React.useEffect(() => {
if layoutClass.\"type" == Tabs {
let isCard = cardOptions->Array.includes(selectedOption)
if !isCard {
let (cardArr, dropdownArr) = CardUtils.swapCardOption(
cardOptions,
dropDownOptions,
selectedOption,
)
setCardOptions(_ => cardArr)
setDropDownOptions(_ => dropdownArr)
}
}
if selectedOption !== "" {
loggerState.setLogInfo(
~value="",
~eventName=PAYMENT_METHOD_CHANGED,
~paymentMethod=selectedOption->String.toUpperCase,
)
}
None
}, (selectedOption, cardOptions, dropDownOptions))
React.useEffect(() => {
let cardsCount: int = cardsToRender(cardsContainerWidth)
let cardOpts = Array.slice(~start=0, ~end=cardsCount, paymentOptions)
let dropOpts = paymentOptions->Array.sliceToEnd(~start=cardsCount)
let isCard: bool = cardOpts->Array.includes(selectedOption)
if !isCard && selectedOption !== "" && paymentOptions->Array.includes(selectedOption) {
let (cardArr, dropdownArr) = CardUtils.swapCardOption(cardOpts, dropOpts, selectedOption)
setCardOptions(_ => cardArr)
setDropDownOptions(_ => dropdownArr)
} else {
setCardOptions(_ => cardOpts)
setDropDownOptions(_ => dropOpts)
}
None
}, (cardsContainerWidth, paymentOptions))
let cardShimmerCount = React.useMemo(() => {
cardsToRender(cardsContainerWidth)
}, [cardsContainerWidth])
let submitCallback = React.useCallback((ev: Window.event) => {
let json = ev.data->safeParse
let confirm = json->getDictFromJson->ConfirmType.itemToObjMapper
if confirm.doSubmit && selectedOption == "" {
postFailedSubmitResponse(~errortype="validation_error", ~message="Select a payment method")
}
}, [selectedOption])
useSubmitPaymentData(submitCallback)
React.useEffect(() => {
setSelectedOption(prev =>
selectedOption !== ""
? prev
: layoutClass.defaultCollapsed
? ""
: switch paymentMethodList {
| SemiLoaded
| LoadError(_) =>
showCardFormByDefault && checkPriorityList(paymentMethodOrder) ? "card" : ""
| Loaded(_) =>
paymentOptions->Array.includes(selectedOption) && showCardFormByDefault
? selectedOption
: paymentOptions->Array.get(0)->Option.getOr("")
| _ => paymentOptions->Array.get(0)->Option.getOr("")
}
)
None
}, (
layoutClass.defaultCollapsed,
paymentOptions,
paymentMethodList,
selectedOption,
showCardFormByDefault,
))
let checkRenderOrComp = () => {
walletOptions->Array.includes("paypal") || isShowOrPayUsing
}
let loader = () => {
handlePostMessageEvents(
~complete=false,
~empty=false,
~paymentType=selectedOption,
~loggerState,
)
<PaymentShimmer />
}
let checkoutEle = {
<ErrorBoundary key={selectedOption} componentName="PaymentElement" publishableKey>
{switch selectedOption->PaymentModeType.paymentMode {
| Card => <CardPayment cardProps expiryProps cvcProps paymentType />
| Klarna =>
<ReusableReactSuspense loaderComponent={loader()} componentName="KlarnaPaymentLazy">
<KlarnaPaymentLazy paymentType />
</ReusableReactSuspense>
| ACHTransfer =>
<ReusableReactSuspense loaderComponent={loader()} componentName="ACHBankTransferLazy">
<ACHBankTransferLazy paymentType />
</ReusableReactSuspense>
| SepaTransfer =>
<ReusableReactSuspense loaderComponent={loader()} componentName="SepaBankTransferLazy">
<SepaBankTransferLazy paymentType />
</ReusableReactSuspense>
| InstantTransfer =>
<ReusableReactSuspense loaderComponent={loader()} componentName="InstantBankTransferLazy">
<InstantBankTransferLazy paymentType />
</ReusableReactSuspense>
| BacsTransfer =>
<ReusableReactSuspense loaderComponent={loader()} componentName="BacsBankTransferLazy">
<BacsBankTransferLazy paymentType />
</ReusableReactSuspense>
| ACHBankDebit =>
<ReusableReactSuspense loaderComponent={loader()} componentName="ACHBankDebitLazy">
<ACHBankDebitLazy paymentType />
</ReusableReactSuspense>
| SepaBankDebit =>
<ReusableReactSuspense loaderComponent={loader()} componentName="SepaBankDebitLazy">
<SepaBankDebitLazy paymentType />
</ReusableReactSuspense>
| BacsBankDebit =>
<ReusableReactSuspense loaderComponent={loader()} componentName="BacsBankDebitLazy">
<BacsBankDebitLazy paymentType />
</ReusableReactSuspense>
| BanContactCard =>
<CardPayment cardProps expiryProps cvcProps paymentType isBancontact=true />
| BecsBankDebit =>
<ReusableReactSuspense loaderComponent={loader()} componentName="BecsBankDebitLazy">
<BecsBankDebitLazy paymentType />
</ReusableReactSuspense>
| Boleto =>
<ReusableReactSuspense loaderComponent={loader()} componentName="BoletoLazy">
<BoletoLazy paymentType />
</ReusableReactSuspense>
| ApplePay =>
switch applePayToken {
| ApplePayTokenOptional(optToken) =>
<ReusableReactSuspense loaderComponent={loader()} componentName="ApplePayLazy">
<ApplePayLazy sessionObj=optToken walletOptions paymentType />
</ReusableReactSuspense>
| _ => React.null
}
| GooglePay =>
<SessionPaymentWrapper type_={Wallet}>
{switch gPayToken {
| OtherTokenOptional(optToken) =>
<ReusableReactSuspense loaderComponent={loader()} componentName="GPayLazy">
{switch googlePayThirdPartyToken {
| GooglePayThirdPartyTokenOptional(googlePayThirdPartyOptToken) =>
<GPayLazy
sessionObj=optToken
thirdPartySessionObj=googlePayThirdPartyOptToken
walletOptions
paymentType
/>
| _ =>
<GPayLazy sessionObj=optToken thirdPartySessionObj=None walletOptions paymentType />
}}
</ReusableReactSuspense>
| _ => React.null
}}
</SessionPaymentWrapper>
| PayPal =>
<SessionPaymentWrapper type_={Wallet}>
{switch paypalToken {
| OtherTokenOptional(optToken) =>
switch (optToken, isPaypalSDKFlow, isPaypalRedirectFlow) {
| (Some(_token), true, _) => {
loggerState.setLogInfo(
~value="PayPal Invoke SDK Flow in Tabs",
~eventName=PAYPAL_SDK_FLOW,
)
React.null
}
| (_, _, true) => <PayPalLazy paymentType walletOptions />
| _ => React.null
}
| _ =>
<RenderIf condition={isPaypalRedirectFlow}>
<PayPalLazy paymentType walletOptions />
</RenderIf>
}}
</SessionPaymentWrapper>
| _ =>
<ReusableReactSuspense loaderComponent={loader()} componentName="PaymentMethodsWrapperLazy">
<PaymentMethodsWrapperLazy paymentType paymentMethodName=selectedOption />
</ReusableReactSuspense>
}}
</ErrorBoundary>
}
let paymentLabel = if displaySavedPaymentMethods {
showFields
? optionAtomValue.paymentMethodsHeaderText
: optionAtomValue.savedPaymentMethodsHeaderText
} else {
optionAtomValue.paymentMethodsHeaderText
}
React.useEffect(() => {
let evalMethodsList = () =>
switch paymentMethodList {
| SemiLoaded | LoadError(_) | Loaded(_) =>
messageParentWindow([("ready", true->JSON.Encode.bool)])
| _ => ()
}
if !displaySavedPaymentMethods {
evalMethodsList()
} else {
switch customerPaymentMethods {
| LoadingSavedCards => ()
| LoadedSavedCards(list, _) =>
list->Array.length > 0
? messageParentWindow([("ready", true->JSON.Encode.bool)])
: evalMethodsList()
| NoResult(_) => evalMethodsList()
}
}
None
}, (paymentMethodList, customerPaymentMethods))
React.useEffect(() => {
let fetchCards = async () => {
switch clickToPayConfig.isReady {
| Some(true) =>
let cardsResult = await ClickToPayHelpers.getCards(loggerState)
switch cardsResult {
| Ok(cards) =>
setClickToPayConfig(prev => {
...prev,
clickToPayCards: Some(cards),
})
| Error(_) => ()
}
| _ => ()
}
}
fetchCards()->ignore
None
}, [clickToPayConfig.isReady])
<>
<RenderIf condition={paymentLabel->Option.isSome}>
<div className="text-2xl font-semibold text-[#151619] mb-6" role="heading" ariaLevel={1}>
{paymentLabel->Option.getOr("")->React.string}
</div>
</RenderIf>
{if clickToPayConfig.isReady->Option.isNone {
if areClickToPayUIScriptsLoaded {
<ClickToPayHelpers.SrcLoader />
} else {
<PaymentElementShimmer.SavedPaymentCardShimmer />
}
} else {
<RenderIf
condition={!showFields &&
(displaySavedPaymentMethods || isShowPaymentMethodsDependingOnClickToPay)}>
<SavedMethods
paymentToken
setPaymentToken
savedMethods
loadSavedCards
cvcProps
paymentType
sessions
isClickToPayAuthenticateError
setIsClickToPayAuthenticateError
/>
</RenderIf>
}}
<RenderIf
condition={(paymentOptions->Array.length > 0 || walletOptions->Array.length > 0) &&
showFields &&
clickToPayConfig.isReady->Option.isSome}>
<div
className="flex flex-col place-items-center"
role="region"
ariaLabel="Payment Section"
tabIndex={0}>
<ErrorBoundary
key="payment_request_buttons_all"
level={ErrorBoundary.RequestButton}
componentName="PaymentRequestButtonElement">
<PaymentRequestButtonElement sessions walletOptions paymentType />
</ErrorBoundary>
<RenderIf
condition={paymentOptions->Array.length > 0 &&
walletOptions->Array.length > 0 &&
checkRenderOrComp()}>
<Or />
</RenderIf>
{switch layoutClass.\"type" {
| Tabs =>
<PaymentOptions
setCardsContainerWidth
cardOptions
dropDownOptions
checkoutEle
cardShimmerCount
cardProps
/>
| Accordion => <AccordionContainer paymentOptions checkoutEle cardProps />
}}
</div>
</RenderIf>
<RenderIf
condition={((displaySavedPaymentMethods && savedMethods->Array.length > 0) ||
isShowPaymentMethodsDependingOnClickToPay) && showFields}>
<div
className="Label flex flex-row gap-3 items-end cursor-pointer mt-4"
style={
fontSize: "14px",
float: "left",
fontWeight: themeObj.fontWeightNormal,
width: "fit-content",
color: themeObj.colorPrimary,
}
tabIndex=0
role="button"
ariaLabel="Click to use existing payment methods"
onKeyDown={event => {
let key = JsxEvent.Keyboard.key(event)
let keyCode = JsxEvent.Keyboard.keyCode(event)
if key == "Enter" || keyCode == 13 {
setShowFields(_ => false)
}
}}
onClick={_ => setShowFields(_ => false)}>
<Icon name="circle_dots" size=20 width=19 />
{React.string(localeString.useExistingPaymentMethods)}
</div>
</RenderIf>
{switch paymentMethodList {
| LoadError(_) =>
<RenderIf condition={paymentMethodListValue.payment_methods->Array.length === 0}>
<ErrorBoundary.ErrorTextAndImage divRef level={Top} />
</RenderIf>
| _ =>
<RenderIf
condition={!displaySavedPaymentMethods &&
paymentOptions->Array.length == 0 &&
walletOptions->Array.length == 0}>
<PaymentElementShimmer />
</RenderIf>
}}
<RenderIf condition={sdkHandleConfirmPayment.handleConfirm}>
<div className="mt-4">
<PayNowButton />
</div>
</RenderIf>
<PoweredBy />
</>
}
| 5,361 | 10,342 |
hyperswitch-web
|
src/BubblegumTheme.res
|
.res
|
open CardThemeType
let bubblegum = {
fontFamily: "",
fontSizeBase: "1rem",
colorPrimary: "#f360a6",
colorBackground: "#ffffff",
colorText: "#545454",
colorDanger: "#fd1717",
colorDangerText: "#fd1717",
borderRadius: "2px",
fontVariantLigatures: "",
fontVariationSettings: "",
spacingUnit: "11px",
fontWeightLight: "400",
fontWeightNormal: "500",
fontWeightMedium: "600",
fontWeightBold: "700",
fontLineHeight: "",
fontSize2Xl: "24px",
fontSizeXl: "16px",
fontSizeLg: "14px",
fontSizeSm: "12px",
fontSizeXs: "10px",
fontSize2Xs: "8px",
fontSize3Xs: "6px",
colorSuccess: "",
colorWarning: "",
colorPrimaryText: "#5469d4",
colorBackgroundText: "",
colorSuccessText: "",
colorWarningText: "",
colorTextSecondary: "#6d6e78",
colorTextPlaceholder: "",
spacingTab: "12px",
borderColor: "#e6e6e6",
spacingAccordionItem: "10px",
colorIconCardCvc: "",
colorIconCardCvcError: "#fd1717",
colorIconCardError: "#fd1717",
spacingGridColumn: "20px",
spacingGridRow: "20px",
buttonBackgroundColor: "#006df9",
buttonHeight: "48px",
buttonWidth: "100%",
buttonBorderRadius: "4px",
buttonBorderColor: "#ffffff",
buttonTextColor: "#ffffff",
buttonTextFontSize: "16px",
buttonTextFontWeight: "500",
buttonBorderWidth: "0px",
}
let bubblegumRules = theme =>
{
".Tab": {
"border": "0",
"borderRadius": theme.borderRadius,
"backgroundColor": theme.colorBackground,
"color": theme.colorTextSecondary,
"alignItems": "start",
"transition": "background .15s ease, border .15s ease, box-shadow .15s ease",
"boxShadow": "0px 3px 10px rgba(18, 42, 66, 0.08)",
},
".Tab:hover": {
"border": "0",
"color": theme.colorText,
},
".Tab:focus": {
"border": "0",
},
".Label": {
"color": theme.colorText,
"opacity": "10",
"textAlign": "left",
},
".Tab--selected": {
"color": "#fff",
"backgroundColor": "#f360a6",
"boxShadow": `0px 1px 1px rgba(0, 0, 0, 0.03), 0px 3px 6px rgba(18, 42, 66, 0.02), 0 0 0 2px ${theme.colorPrimary}`,
},
".Tab--selected:hover": {
"color": "#fff",
"backgroundColor": "#f360a6",
"boxShadow": `0px 1px 1px rgba(0, 0, 0, 0.03), 0px 3px 6px rgba(18, 42, 66, 0.02), 0 0 0 2px ${theme.colorPrimary}`,
},
".Tab--selected:focus": {
"color": "#fff",
"backgroundColor": "#f360a6",
"boxShadow": `0 0 0 2px ${theme.colorPrimary}4c, 0 1px 1px 0 ${theme.colorBackground}, 0 0 0 1px ${theme.colorPrimary}4c`,
},
".TabMore:focus": {
"border": `1px solid ${theme.colorPrimary}`,
"boxShadow": `${theme.colorPrimary}4c 0px 0px 0px 3px`,
},
".TabMore": {
"border": `1px solid ${theme.borderColor}`,
},
".Input": {
"border": `1px solid #e6e6e6`,
"color": theme.colorText,
"fontWeight": theme.fontWeightLight,
"borderRadius": theme.borderRadius,
"boxShadow": "0px 3px 10px rgba(18, 42, 66, 0.08)",
"transition": "background 0.15s ease, border 0.15s ease, box-shadow 0.15s ease, color 0.15s ease",
},
".Input-Compressed": {
"border": `1px solid #e6e6e6`,
"color": theme.colorText,
"fontWeight": theme.fontWeightLight,
"boxShadow": `0px 1px 1px rgb(0 0 0 / 3%), 0px 3px 6px rgb(0 0 0 / 2%)`,
"transition": "background 0.15s ease, border 0.15s ease, box-shadow 0.15s ease, color 0.15s ease",
},
".Input:-webkit-autofill": {
"transition": "background-color 5000s ease-in-out 0s",
"-webkitTextFillColor": `${theme.colorText} !important`,
},
".Input:focus": {
"border": `1px solid ${theme.colorPrimary}`,
"boxShadow": `${theme.colorPrimary}4c 0px 0px 0px 3px`,
},
".Input-Compressed:focus": {
"border": `1px solid ${theme.colorPrimary}`,
"boxShadow": `${theme.colorPrimary}4c 0px 0px 0px 2px`,
"position": "relative",
"zIndex": "2",
},
".Input--invalid": {
"color": theme.colorDanger,
"border": `1px solid ${theme.colorDanger}`,
"transition": "border 0.15s ease, box-shadow 0.15s ease, color 0.15s ease",
},
".Input::placeholder": {
"fontWeight": theme.fontWeightLight,
"color": theme.colorTextPlaceholder,
},
".InputLogo": {
"color": "#979797",
},
".TabLabel": {
"transition": "color .1s ease",
"textAlign": "start",
},
".TabIcon": {
"transition": "color .1s ease",
},
".Block": {
"backgroundColor": theme.colorBackground,
"borderRadius": theme.borderRadius,
// "border": `1px solid ${theme.borderColor}`,
"borderColor": "transparent",
"boxShadow": "0px 3px 10px rgba(18, 42, 66, 0.08)",
},
".BlockDivider": {
"backgroundColor": "#ebebeb",
// "border": `1px solid ${theme.borderColor}`,
},
".AccordionItem": {
"backgroundColor": theme.colorBackground,
"color": theme.colorTextSecondary,
"transition": "height 1s ease",
"boxShadow": "0px 1px 1px rgb(0 0 0 / 3%), 0px 3px 6px rgb(0 0 0 / 2%)",
"padding": "20px",
},
".AccordionMore": {
"backgroundColor": theme.colorBackground,
"color": theme.colorTextSecondary,
"border": `1px solid ${theme.borderColor}`,
},
".AccordionMore:hover": {
"color": theme.colorText,
},
".AccordionItem:hover": {
"color": theme.colorText,
},
".AccordionItem--selected": {
"color": theme.colorPrimary,
},
".AccordionItem--selected:hover": {
"color": theme.colorPrimary,
},
".AccordionItemLabel": {
"transition": "color .1s ease",
},
".AccordionItemLabel--selected": {
"color": theme.colorPrimary,
},
".AccordionItemIcon--selected": {
"color": theme.colorPrimary,
},
".PickerItem": {
"backgroundColor": theme.colorBackground,
"borderRadius": theme.borderRadius,
"border": `1px solid ${theme.borderColor}`,
"color": theme.colorTextSecondary,
"padding": theme.spacingUnit,
"transition": "height 1s ease",
"boxShadow": "0px 1px 1px rgb(0 0 0 / 3%), 0px 3px 6px rgb(0 0 0 / 2%)",
},
".PickerItem:hover": {
"color": theme.colorText,
},
".PickerItem--selected": {
"color": theme.colorPrimary,
"border": `1px solid ${theme.colorPrimary}`,
"boxShadow": `${theme.colorPrimary}4c 0px 0px 0px 3px`,
},
".PickerItem--selected:hover": {
"color": theme.colorPrimary,
"border": `1px solid ${theme.colorPrimary}`,
"boxShadow": `${theme.colorPrimary}4c 0px 0px 0px 3px`,
},
".Checkbox": {
"fontWeight": theme.fontWeightLight,
"fontSize": theme.fontSizeLg,
},
".CheckboxInput": {
"boxShadow": "0px 3px 10px rgba(18, 42, 66, 0.08)",
},
".PaymentMethodsHeaderLabel": {
"color": theme.colorText,
"fontSize": theme.fontSize2Xl,
"fontWeight": theme.fontWeightMedium,
"marginBottom": "1.5rem",
},
}->Identity.anyTypeToJson
let default = bubblegum
let defaultRules = bubblegumRules
| 2,297 | 10,343 |
hyperswitch-web
|
src/index.css
|
.css
|
/* Remove blue outline of input, button in firefox */
@-moz-document url-prefix() {
*:focus,
*:focus-visible,
*:focus-within,
*:active,
*:visited {
outline: none !important;
}
}
/* Remove contact and password icon in safari */
input::-webkit-credentials-auto-fill-button,
input::-webkit-contacts-auto-fill-button {
width: 0 !important;
}
| 93 | 10,344 |
hyperswitch-web
|
src/Icon.res
|
.res
|
@react.component
let make = (
~name,
~size=20,
~width=size,
~className=?,
~iconType="orca",
~onClick=?,
~style=ReactDOMStyle.make(),
~shouldMirrorIcon=false,
) => {
let otherClasses = switch className {
| Some(str) => str
| None => ""
}
<svg
?onClick
style
className={`fill-current ${otherClasses}`}
width={Int.toString(width) ++ "px"}
height={Int.toString(size) ++ "px"}
transform={shouldMirrorIcon ? "scale(-1,1)" : ""}>
<use xlinkHref={`${GlobalVars.repoPublicPath}/icons/${iconType}.svg#${name}`} />
</svg>
}
| 168 | 10,345 |
hyperswitch-web
|
src/TabCard.res
|
.res
|
open RecoilAtoms
@react.component
let make = (~paymentOption: PaymentMethodsRecord.paymentFieldsInfo, ~isActive: bool) => {
let {themeObj, localeString} = Recoil.useRecoilValueFromAtom(configAtom)
let {readOnly, customMethodNames} = Recoil.useRecoilValueFromAtom(optionAtom)
let setSelectedOption = Recoil.useSetRecoilState(selectedOptionAtom)
let (tabClass, tabLabelClass, tabIconClass) = React.useMemo(
() => isActive ? ("Tab--selected", "TabLabel--selected", "TabIcon--selected") : ("", "", ""),
[isActive],
)
let (displayName, icon) = PaymentUtils.getDisplayNameAndIcon(
customMethodNames,
paymentOption.paymentMethodName,
paymentOption.displayName,
paymentOption.icon,
)
let onClick = _ => {
setSelectedOption(_ => paymentOption.paymentMethodName)
}
<button
className={`Tab ${tabClass} flex flex-col animate-slowShow`}
type_="button"
disabled=readOnly
style={
minWidth: "5rem",
overflowWrap: "anywhere",
width: "100%",
padding: themeObj.spacingUnit,
cursor: "pointer",
}
onClick>
<div className={`TabIcon ${tabIconClass}`}>
{switch icon {
| Some(ele) => ele
| None => <Icon name="default-card" size=19 />
}}
</div>
<div className={`TabLabel ${tabLabelClass}`}>
{React.string(paymentOption.paymentMethodName === "card" ? localeString.card : displayName)}
</div>
</button>
}
| 360 | 10,346 |
hyperswitch-web
|
src/SingleLineCardPayment.res
|
.res
|
open RecoilAtoms
open CardUtils
@react.component
let make = (
~paymentType: CardThemeType.mode,
~cardProps,
~expiryProps,
~cvcProps,
~zipProps,
~handleElementFocus,
~isFocus,
) => {
let {iframeId} = Recoil.useRecoilValueFromAtom(keys)
let options = Recoil.useRecoilValueFromAtom(elementOptions)
let {localeString} = Recoil.useRecoilValueFromAtom(configAtom)
let (
isCardValid,
setIsCardValid,
_,
cardNumber,
changeCardNumber,
handleCardBlur,
cardRef,
icon,
_,
_,
maxCardLength,
_,
) = cardProps
let (
isExpiryValid,
setIsExpiryValid,
cardExpiry,
changeCardExpiry,
handleExpiryBlur,
expiryRef,
onExpiryKeyDown,
_,
_,
) = expiryProps
let (
isCVCValid,
setIsCVCValid,
cvcNumber,
_,
changeCVCNumber,
handleCVCBlur,
cvcRef,
onCvcKeyDown,
_,
_,
) = cvcProps
let (
isZipValid,
setIsZipValid,
zipCode,
changeZipCode,
handleZipBlur,
zipRef,
onZipCodeKeyDown,
displayPincode,
) = zipProps
let isCardValidValue = getBoolOptionVal(isCardValid)
let isExpiryValidValue = getBoolOptionVal(isExpiryValid)
let isCVCValidValue = getBoolOptionVal(isCVCValid)
let isZipValidValue = getBoolOptionVal(isZipValid)
let (showPincode, pincodeClass) = React.useMemo(
() => displayPincode ? ("block", "animate-slideLeft") : ("none", "animate-slideRight "),
[displayPincode],
)
let checkLengthIsZero = item => String.length(item) == 0
let checkValueIsValid = item => item == "valid"
let checkValueIsInvalid = item => item == "invalid"
let (cardEmpty, cardComplete, cardInvalid, cardFocused) = React.useMemo(() => {
let isCardDetailsEmpty = Array.every(
[cardNumber, cardExpiry, cvcNumber, zipCode],
checkLengthIsZero,
)
? `${options.classes.base} ${options.classes.empty} `
: options.classes.base
let isCardDetailsValid = Array.every(
[isCardValidValue, isExpiryValidValue, isCVCValidValue, isZipValidValue],
checkValueIsValid,
)
? ` ${options.classes.complete} `
: ``
let isCardDetailsInvalid = Array.some(
[isCardValidValue, isExpiryValidValue, isCVCValidValue, isZipValidValue],
checkValueIsInvalid,
)
? ` ${options.classes.invalid} `
: ``
let isCardDetailsFocused = isFocus ? ` ${options.classes.focus} ` : ``
(isCardDetailsEmpty, isCardDetailsValid, isCardDetailsInvalid, isCardDetailsFocused)
}, (cardProps, expiryProps, cvcProps, zipProps))
let concatString = Array.joinWith([cardEmpty, cardComplete, cardInvalid, cardFocused], "")
React.useEffect(() => {
Utils.messageParentWindow([
("id", iframeId->JSON.Encode.string),
("concatedString", concatString->JSON.Encode.string),
])
None
}, [concatString])
<div disabled=options.disabled className="flex flex-col">
<div className="flex flex-row m-auto w-full justify-between items-center">
{<div className="flex flex-row w-full items-center">
<RenderIf condition={!options.hideIcon}>
<div className="w-[12%] relative flex items-center"> {icon} </div>
</RenderIf>
<div className="w-10/12">
<InputField
isValid=isCardValid
setIsValid=setIsCardValid
value=cardNumber
onChange=changeCardNumber
onBlur=handleCardBlur
onFocus=handleElementFocus
type_="tel"
maxLength=maxCardLength
paymentType
inputRef=cardRef
placeholder="1234 1234 1234 1234"
isFocus
/>
</div>
</div>}
{<div className="flex flex-row justify-end w-5/12">
<div className="w-2/5">
<InputField
onKeyDown=onExpiryKeyDown
isValid=isExpiryValid
setIsValid=setIsExpiryValid
value=cardExpiry
onChange=changeCardExpiry
onBlur=handleExpiryBlur
onFocus=handleElementFocus
type_="tel"
paymentType
maxLength=7
inputRef=expiryRef
placeholder=localeString.expiryPlaceholder
isFocus
/>
</div>
<div className="w-1/5">
<InputField
onKeyDown=onCvcKeyDown
isValid=isCVCValid
setIsValid=setIsCVCValid
value=cvcNumber
onChange=changeCVCNumber
onBlur=handleCVCBlur
onFocus=handleElementFocus
paymentType
type_="tel"
className={`tracking-widest w-auto`}
maxLength=4
inputRef=cvcRef
placeholder="123"
isFocus
/>
</div>
<RenderIf condition={!options.hidePostalCode}>
<div className={`w-2/5 ${pincodeClass} slowShow`} style={display: showPincode}>
<InputField
onKeyDown=onZipCodeKeyDown
isValid=isZipValid
setIsValid=setIsZipValid
value=zipCode
onChange=changeZipCode
onBlur=handleZipBlur
onFocus=handleElementFocus
paymentType
type_="tel"
inputRef=zipRef
placeholder="ZIP"
isFocus
/>
</div>
</RenderIf>
</div>}
</div>
</div>
}
let default = make
| 1,390 | 10,347 |
hyperswitch-web
|
src/Types/ElementType.res
|
.res
|
open ErrorUtils
type classes = {
base: string,
complete: string,
empty: string,
focus: string,
invalid: string,
webkitAutofill: string,
}
type rec styleClass = {
backgroundColor: string,
color: string,
fontFamily: string,
fontSize: string,
fontSmoothing: string,
fontStyle: string,
fontVariant: string,
fontWeight: string,
iconColor: string,
lineHeight: string,
letterSpacing: string,
textAlign: string,
padding: string,
textDecoration: string,
textShadow: string,
textTransform: string,
hover: option<styleClass>,
focus: option<styleClass>,
selection: option<styleClass>,
webkitAutofill: option<styleClass>,
disabled: option<styleClass>,
msClear: option<styleClass>,
placeholder: option<styleClass>,
}
type theme = Dark | Light | LightOutline
type iconStyle = Default | Solid
type paymentRequestButtonStyle = {
type_: string,
theme: theme,
height: string,
}
type style = {
base: JSON.t,
complete: JSON.t,
empty: JSON.t,
invalid: JSON.t,
paymentRequestButton: paymentRequestButtonStyle,
}
type options = {
classes: classes,
style: style,
value: string,
hidePostalCode: bool,
iconStyle: iconStyle,
hideIcon: bool,
showIcon: bool,
disabled: bool,
}
let getIconStyle = (str, logger) => {
switch str {
| "default" => Default
| "solid" => Solid
| str => {
str->unknownPropValueWarning(["default", "solid"], "options.iconStyle", ~logger)
Default
}
}
}
open Utils
let defaultClasses = {
base: "OrcaElement",
complete: "OrcaElement--complete",
empty: "OrcaElement--empty",
focus: "OrcaElement--focus",
invalid: "OrcaElement--invalid",
webkitAutofill: "OrcaElement--webkit-autofill",
}
let defaultStyleClass = {
backgroundColor: "",
color: "",
fontFamily: "",
fontSize: "",
fontSmoothing: "",
fontStyle: "",
fontVariant: "",
fontWeight: "",
iconColor: "",
lineHeight: "",
letterSpacing: "",
textAlign: "",
padding: "",
textDecoration: "",
textShadow: "",
textTransform: "",
hover: None,
focus: None,
placeholder: None,
selection: None,
webkitAutofill: None,
disabled: None,
msClear: None,
}
let defaultPaymentRequestButton = {
type_: "default",
theme: Dark,
height: "",
}
let defaultStyle = {
base: Dict.make()->JSON.Encode.object,
complete: Dict.make()->JSON.Encode.object,
empty: Dict.make()->JSON.Encode.object,
invalid: Dict.make()->JSON.Encode.object,
paymentRequestButton: defaultPaymentRequestButton,
}
let defaultOptions = {
classes: defaultClasses,
style: defaultStyle,
value: "",
hidePostalCode: false,
iconStyle: Default,
hideIcon: false,
showIcon: false,
disabled: false,
}
let getClasses = (str, dict, logger) => {
dict
->Dict.get(str)
->Option.flatMap(JSON.Decode.object)
->Option.map(json => {
{
base: getWarningString(json, "base", "OrcaElement", ~logger),
complete: getWarningString(json, "complete", "OrcaElement--complete", ~logger),
empty: getWarningString(json, "empty", "OrcaElement--empty", ~logger),
focus: getWarningString(json, "focus", "OrcaElement--focus", ~logger),
invalid: getWarningString(json, "invalid", "OrcaElement--invalid", ~logger),
webkitAutofill: getWarningString(
json,
"webkitAutofill",
"OrcaElement--webkit-autofill",
~logger,
),
}
})
->Option.getOr(defaultClasses)
}
let rec getStyleObj = (dict, str, logger) => {
dict
->Dict.get(str)
->Option.flatMap(JSON.Decode.object)
->Option.map(json => {
{
backgroundColor: getWarningString(json, "backgroundColor", "", ~logger),
color: getWarningString(json, "color", "", ~logger),
fontFamily: getWarningString(json, "fontFamily", "", ~logger),
fontSize: getWarningString(json, "fontSize", "", ~logger),
fontSmoothing: getWarningString(json, "fontSmoothing", "", ~logger),
fontStyle: getWarningString(json, "fontStyle", "", ~logger),
fontVariant: getWarningString(json, "fontVariant", "", ~logger),
fontWeight: getWarningString(json, "fontWeight", "", ~logger),
iconColor: getWarningString(json, "iconColor", "", ~logger),
lineHeight: getWarningString(json, "lineHeight", "", ~logger),
letterSpacing: getWarningString(json, "letterSpacing", "", ~logger),
textAlign: getWarningString(json, "textAlign", "", ~logger),
padding: getWarningString(json, "padding", "", ~logger),
textDecoration: getWarningString(json, "textDecoration", "", ~logger),
textShadow: getWarningString(json, "textShadow", "", ~logger),
textTransform: getWarningString(json, "textTransform", "", ~logger),
placeholder: Some(getStyleObj(json, "::placeholder", logger)),
hover: Some(getStyleObj(json, ":hover", logger)),
focus: Some(getStyleObj(json, ":focus", logger)),
selection: Some(getStyleObj(json, "::selection", logger)),
webkitAutofill: Some(getStyleObj(json, ":-webkit-autofill", logger)),
disabled: Some(getStyleObj(json, ":disabled", logger)),
msClear: Some(getStyleObj(json, "::-ms-clear", logger)),
}
})
->Option.getOr(defaultStyleClass)
}
let getTheme = (str, key, logger) => {
switch str {
| "dark" => Dark
| "light" => Light
| "light-outline" => LightOutline
| str => {
str->unknownPropValueWarning(["dark", "light", "light-outline"], key, ~logger)
Dark
}
}
}
let getPaymentRequestButton = (dict, str, logger) => {
dict
->Dict.get(str)
->Option.flatMap(JSON.Decode.object)
->Option.map(json => {
{
type_: getWarningString(json, "type", "", ~logger),
theme: getWarningString(json, "theme", "dark", ~logger)->getTheme(
"elements.options.style.paymentRequestButton.theme",
logger,
),
height: getWarningString(json, "height", "", ~logger),
}
})
->Option.getOr(defaultPaymentRequestButton)
}
let getStyle = (dict, str, logger) => {
dict
->Dict.get(str)
->Option.flatMap(JSON.Decode.object)
->Option.map(json => {
{
base: getJsonObjectFromDict(json, "base"),
complete: getJsonObjectFromDict(json, "complete"),
empty: getJsonObjectFromDict(json, "empty"),
invalid: getJsonObjectFromDict(json, "invalid"),
paymentRequestButton: getPaymentRequestButton(json, "paymentRequestButton", logger),
}
})
->Option.getOr(defaultStyle)
}
let itemToObjMapper = (dict, logger) => {
unknownKeysWarning(
[
"classes",
"style",
"value",
"hidePostalCode",
"iconStyle",
"hideIcon",
"showIcon",
"disabled",
],
dict,
"options",
~logger,
)
{
classes: getClasses("classes", dict, logger),
style: getStyle(dict, "style", logger),
value: getWarningString(dict, "value", "", ~logger),
hidePostalCode: getBoolWithWarning(dict, "hidePostalCode", false, ~logger),
iconStyle: getWarningString(dict, "iconStyle", "default", ~logger)->getIconStyle(logger),
hideIcon: getBoolWithWarning(dict, "hideIcon", false, ~logger),
showIcon: getBoolWithWarning(dict, "showIcon", false, ~logger),
disabled: getBoolWithWarning(dict, "disabled", false, ~logger),
}
}
| 1,856 | 10,348 |
hyperswitch-web
|
src/Types/PaymentConfirmTypes.res
|
.res
|
type achCreditTransfer = {
account_number: string,
bank_name: string,
routing_number: string,
swift_code: string,
}
let defaultACHCreditTransfer = {
account_number: "",
bank_name: "",
routing_number: "",
swift_code: "",
}
type bacsBankInstruction = {
sort_code: string,
account_number: string,
account_holder_name: string,
}
let defaultBacsBankInstruction = {
sort_code: "",
account_number: "",
account_holder_name: "",
}
type bankTransfer = {ach_credit_transfer: achCreditTransfer}
type redirectToUrl = {
returnUrl: string,
url: string,
}
type voucherDetails = {
download_url: string,
reference: string,
}
type nextAction = {
redirectToUrl: string,
type_: string,
bank_transfer_steps_and_charges_details: option<JSON.t>,
session_token: option<JSON.t>,
image_data_url: option<string>,
three_ds_data: option<JSON.t>,
voucher_details: option<voucherDetails>,
display_to_timestamp: option<float>,
next_action_data: option<JSON.t>,
display_text: option<string>,
border_color: option<string>,
iframe_data: option<JSON.t>,
}
type intent = {
nextAction: nextAction,
status: string,
paymentId: string,
clientSecret: string,
error_message: string,
payment_method_type: string,
manualRetryAllowed: bool,
connectorTransactionId: string,
}
open Utils
let defaultRedirectTourl = {
returnUrl: "",
url: "",
}
let defaultNextAction = {
redirectToUrl: "",
type_: "",
bank_transfer_steps_and_charges_details: None,
session_token: None,
image_data_url: None,
three_ds_data: None,
voucher_details: None,
display_to_timestamp: None,
next_action_data: None,
display_text: None,
border_color: None,
iframe_data: None,
}
let defaultIntent = {
nextAction: defaultNextAction,
status: "",
clientSecret: "",
paymentId: "",
error_message: "",
payment_method_type: "",
manualRetryAllowed: false,
connectorTransactionId: "",
}
let getAchCreditTransfer = (dict, str) => {
dict
->Dict.get(str)
->Option.flatMap(JSON.Decode.object)
->Option.map(json => {
{
account_number: getString(json, "account_number", ""),
bank_name: getString(json, "bank_name", ""),
routing_number: getString(json, "routing_number", ""),
swift_code: getString(json, "swift_code", ""),
}
})
->Option.getOr(defaultACHCreditTransfer)
}
let getBacsBankInstructions = (dict, str) => {
dict
->Dict.get(str)
->Option.flatMap(JSON.Decode.object)
->Option.map(json => {
{
account_holder_name: getString(json, "account_holder_name", ""),
account_number: getString(json, "account_number", ""),
sort_code: getString(json, "sort_code", ""),
}
})
->Option.getOr(defaultBacsBankInstruction)
}
let getBankTransferDetails = (dict, str) => {
dict
->Dict.get(str)
->Option.flatMap(JSON.Decode.object)
->Option.map(json => {
{
ach_credit_transfer: getAchCreditTransfer(json, "ach_credit_transfer"),
}
})
}
let getVoucherDetails = json => {
{
download_url: getString(json, "download_url", ""),
reference: getString(json, "reference", ""),
}
}
let getNextAction = (dict, str) => {
dict
->Dict.get(str)
->Option.flatMap(JSON.Decode.object)
->Option.map(json => {
{
redirectToUrl: getString(json, "redirect_to_url", ""),
type_: getString(json, "type", ""),
bank_transfer_steps_and_charges_details: Some(
getJsonObjFromDict(
json,
"bank_transfer_steps_and_charges_details",
Dict.make(),
)->JSON.Encode.object,
),
session_token: Some(
getJsonObjFromDict(json, "session_token", Dict.make())->JSON.Encode.object,
),
image_data_url: Some(json->getString("image_data_url", "")),
three_ds_data: Some(
json
->Dict.get("three_ds_data")
->Option.getOr(Dict.make()->JSON.Encode.object),
),
display_to_timestamp: Some(
json
->Dict.get("display_to_timestamp")
->Option.flatMap(JSON.Decode.float)
->Option.getOr(0.0),
),
voucher_details: {
json
->Dict.get("voucher_details")
->Option.flatMap(JSON.Decode.object)
->Option.map(json => json->getVoucherDetails)
},
next_action_data: Some(json->getDictFromDict("next_action_data")->JSON.Encode.object),
display_text: json->getOptionString("display_text"),
border_color: json->getOptionString("border_color"),
iframe_data: Some(json->Utils.getJsonObjectFromDict("iframe_data")),
}
})
->Option.getOr(defaultNextAction)
}
let itemToObjMapper = dict => {
{
nextAction: getNextAction(dict, "next_action"),
status: getString(dict, "status", ""),
clientSecret: getString(dict, "client_secret", ""),
paymentId: getString(dict, "payment_id", ""),
error_message: getString(dict, "error_message", ""),
payment_method_type: getString(dict, "payment_method_type", ""),
manualRetryAllowed: getBool(dict, "manual_retry_allowed", false),
connectorTransactionId: getString(dict, "connector_transaction_id", ""),
}
}
| 1,220 | 10,349 |
hyperswitch-web
|
src/Types/PaymentMethodCollectTypes.res
|
.res
|
type paymentMethod =
| Card
| BankTransfer
| Wallet
type card = Credit | Debit
type bankTransfer = ACH | Bacs | Pix | Sepa
type wallet = Paypal | Venmo
type cardExpDate =
| CardExpMonth
| CardExpYear
type paymentMethodDataField =
// Cards
| CardNumber
| CardExpDate(cardExpDate)
| CardHolderName
// Card meta
| CardBrand
// Banks
| ACHRoutingNumber
| ACHAccountNumber
| ACHBankName
| ACHBankCity
| BacsSortCode
| BacsAccountNumber
| BacsBankName
| BacsBankCity
| SepaIban
| SepaBic
| SepaBankName
| SepaBankCity
| SepaCountryCode
// Wallets
| PaypalMail
| PaypalMobNumber
| PixKey
| PixBankAccountNumber
| PixBankName
| VenmoMobNumber
type userFullNameForAddress =
| FirstName
| LastName
type addressField =
| Email
| FullName(userFullNameForAddress)
| CountryCode
| PhoneNumber
| PhoneCountryCode
| AddressLine1
| AddressLine2
| AddressCity
| AddressState
| AddressPincode
| AddressCountry(array<string>)
type dynamicFieldForAddress = {
pmdMap: string,
displayName: string,
fieldType: addressField,
value: option<string>,
}
type dynamicFieldForPaymentMethodData = {
pmdMap: string,
displayName: string,
fieldType: paymentMethodDataField,
value: option<string>,
}
type dynamicFieldInfo =
| BillingAddress(dynamicFieldForAddress)
| PayoutMethodData(dynamicFieldForPaymentMethodData)
type dynamicFieldType =
| BillingAddress(addressField)
| PayoutMethodData(paymentMethodDataField)
type payoutDynamicFields = {
address: option<array<dynamicFieldForAddress>>,
payoutMethodData: array<dynamicFieldForPaymentMethodData>,
}
type paymentMethodTypeWithDynamicFields =
| Card((card, payoutDynamicFields))
| BankTransfer((bankTransfer, payoutDynamicFields))
| Wallet((wallet, payoutDynamicFields))
type paymentMethodType =
| Card(card)
| BankTransfer(bankTransfer)
| Wallet(wallet)
type paymentMethodData = (paymentMethodType, array<(dynamicFieldInfo, string)>)
type formLayout = Journey | Tabs
type journeyViews =
| SelectPM
| SelectPMType(paymentMethod)
| AddressForm(array<dynamicFieldForAddress>)
| PMDForm(paymentMethodType, array<dynamicFieldForPaymentMethodData>)
| FinalizeView(paymentMethodData)
type tabViews =
| DetailsForm
| FinalizeView(paymentMethodData)
type views = Journey(journeyViews) | Tabs(tabViews)
type paymentMethodCollectFlow = PayoutLinkInitiate | PayoutMethodCollect
type paymentMethodCollectOptions = {
enabledPaymentMethods: array<paymentMethodType>,
enabledPaymentMethodsWithDynamicFields: array<paymentMethodTypeWithDynamicFields>,
linkId: string,
payoutId: string,
customerId: string,
theme: string,
collectorName: string,
logo: string,
returnUrl: option<string>,
amount: string,
currency: string,
flow: paymentMethodCollectFlow,
sessionExpiry: string,
formLayout: formLayout,
}
// API TYPES
type payoutStatus =
| Success
| Failed
| Cancelled
| Initiated
| Expired
| Reversed
| Pending
| Ineligible
| RequiresCreation
| RequiresConfirmation
| RequiresPayoutMethodData
| RequiresFulfillment
| RequiresVendorAccountCreation
type payoutSuccessResponse = {
payoutId: string,
merchantId: string,
customerId: string,
amount: float,
currency: string,
connector: option<string>,
payoutType: string,
status: payoutStatus,
errorMessage: option<string>,
errorCode: option<string>,
connectorTransactionId: option<string>,
}
type payoutFailureResponse = {
errorType: string,
code: string,
message: string,
reason: option<string>,
}
type payoutConfirmResponse =
| SuccessResponse(payoutSuccessResponse)
| ErrorResponse(payoutFailureResponse)
type statusInfoField = {
key: string,
value: string,
}
type statusInfo = {
status: payoutStatus,
payoutId: string,
message: string,
code: option<string>,
errorMessage: option<string>,
reason: option<string>,
}
/** DECODERS */
let decodeAmount = (dict, defaultAmount) =>
switch dict->Dict.get("amount") {
| Some(amount) =>
amount
->JSON.Decode.string
->Option.getOr(defaultAmount)
| None => defaultAmount
}
let decodeFlow = (dict, defaultPaymentMethodCollectFlow) =>
switch dict->Dict.get("flow") {
| Some(flow) =>
switch flow->JSON.Decode.string {
| Some("PayoutLinkInitiate") => PayoutLinkInitiate
| Some("PayoutMethodCollect") => PayoutMethodCollect
| _ => defaultPaymentMethodCollectFlow
}
| None => defaultPaymentMethodCollectFlow
}
let decodeFormLayout = (dict, defaultFormLayout): formLayout =>
switch dict->Dict.get("formLayout") {
| Some(formLayout) =>
switch formLayout->JSON.Decode.string {
| Some("journey") => Journey
| Some("tabs") => Tabs
| _ => defaultFormLayout
}
| None => defaultFormLayout
}
let decodeCard = (cardType: string): option<card> =>
switch cardType {
| "credit" => Some(Credit)
| "debit" => Some(Debit)
| _ => None
}
let decodeTransfer = (value: string): option<bankTransfer> =>
switch value {
| "ach" => Some(ACH)
| "sepa" => Some(Sepa)
| "bacs" => Some(Bacs)
| "pix" => Some(Pix)
| _ => None
}
let decodeWallet = (methodType: string): option<wallet> =>
switch methodType {
| "paypal" => Some(Paypal)
| "venmo" => Some(Venmo)
| _ => None
}
let getFieldOptions = dict => {
switch dict
->Dict.get("field_type")
->Option.getOr(Dict.make()->JSON.Encode.object)
->JSON.Classify.classify {
| Object(dict) =>
dict
->Dict.get("user_address_country")
->Option.flatMap(JSON.Decode.object)
->Option.flatMap(obj =>
obj
->Dict.get("options")
->Option.flatMap(JSON.Decode.array)
->Option.map(options => {
let countries = options->Array.filterMap(option => option->JSON.Decode.string)
countries->Array.sort(
(c1, c2) =>
(c1->String.charCodeAt(0)->Float.toInt - c2->String.charCodeAt(0)->Float.toInt)
->Int.toFloat,
)
BillingAddress(AddressCountry(countries))
})
)
| _ => None
}
}
let decodeFieldType = (key: string, fieldType: option<dynamicFieldType>): option<
dynamicFieldType,
> => {
switch (key, fieldType) {
// Card details
| ("payout_method_data.card.card_number", _) => Some(PayoutMethodData(CardNumber))
| ("payout_method_data.card.expiry_month", _) => Some(PayoutMethodData(CardExpDate(CardExpMonth)))
| ("payout_method_data.card.expiry_year", _) => Some(PayoutMethodData(CardExpDate(CardExpYear)))
| ("payout_method_data.card.card_holder_name", _) => Some(PayoutMethodData(CardHolderName))
// SEPA
| ("payout_method_data.bank.iban", _) => Some(PayoutMethodData(SepaIban))
| ("payout_method_data.bank.bic", _) => Some(PayoutMethodData(SepaBic))
// Billing address
| ("billing.address.first_name", _) => Some(BillingAddress(FullName(FirstName)))
| ("billing.address.last_name", _) => Some(BillingAddress(FullName(LastName)))
| ("billing.address.line1", _) => Some(BillingAddress(AddressLine1))
| ("billing.address.line2", _) => Some(BillingAddress(AddressLine2))
| ("billing.address.city", _) => Some(BillingAddress(AddressCity))
| ("billing.address.zip", _) => Some(BillingAddress(AddressPincode))
| ("billing.address.state", _) => Some(BillingAddress(AddressState))
| ("billing.address.country", Some(BillingAddress(AddressCountry(countries)))) =>
Some(BillingAddress(AddressCountry(countries)))
| ("billing.phone.country_code", _) => Some(BillingAddress(PhoneCountryCode))
| ("billing.phone.number", _) => Some(BillingAddress(PhoneNumber))
| _ => fieldType
}
}
let customAddressOrder = [
"billing.address.first_name",
"billing.address.last_name",
"billing.address.line1",
"billing.address.line2",
"billing.address.city",
"billing.address.zip",
"billing.address.state",
"billing.address.country",
"billing.phone.country_code",
"billing.phone.number",
]
let customPmdOrder = [
"payout_method_data.card.card_number",
"payout_method_data.card.expiry_month",
"payout_method_data.card.expiry_year",
"payout_method_data.card.card_holder_name",
"payout_method_data.bank.iban",
"payout_method_data.bank.bic",
]
let createCustomOrderMap = (customOrder: array<string>): Map.t<string, int> => {
customOrder->Array.reduceWithIndex(Map.make(), (map, item, index) => {
map->Map.set(item, index)
map
})
}
let getCustomIndex = (key: string, customOrderMap, defaultIndex) => {
switch customOrderMap->Map.get(key) {
| Some(index) => index
| None => defaultIndex
}
}
let sortByCustomOrder = (arr: array<'a>, getKey: 'a => string, customOrder: array<string>) => {
let customOrderMap = createCustomOrderMap(customOrder)
let defaultIndex = customOrder->Array.length
arr->Js.Array2.sortInPlaceWith((a, b) => {
let indexA = getCustomIndex(getKey(a), customOrderMap, defaultIndex)
let indexB = getCustomIndex(getKey(b), customOrderMap, defaultIndex)
indexA - indexB
})
}
let decodePayoutDynamicFields = (json: JSON.t, defaultDynamicPmdFields): option<
payoutDynamicFields,
> =>
json
->JSON.Decode.object
->Option.map(obj => {
let (address, pmd) =
obj
->Js.Dict.entries
->Array.reduce(([], []), ((addressFields, payoutMethodDataFields), (key, value)) => {
switch JSON.Decode.object(value) {
| Some(fieldObj) => {
let getString = key => fieldObj->Dict.get(key)->Option.flatMap(JSON.Decode.string)
let fieldType = getFieldOptions(fieldObj)
switch (getString("required_field"), getString("display_name"), getString("value")) {
| (Some(pmdMap), Some(displayName), value) =>
switch decodeFieldType(key, fieldType) {
| Some(BillingAddress(fieldType)) =>
let addressField: dynamicFieldForAddress = {
pmdMap,
displayName,
fieldType,
value,
}
([addressField, ...addressFields], payoutMethodDataFields)
| Some(PayoutMethodData(fieldType)) =>
let payoutMethodDataField = {
pmdMap,
displayName,
fieldType,
value,
}
(addressFields, [payoutMethodDataField, ...payoutMethodDataFields])
| None => (addressFields, payoutMethodDataFields)
}
| _ => (addressFields, payoutMethodDataFields)
}
}
| None => (addressFields, payoutMethodDataFields)
}
})
{
address: address->Array.length > 0
? Some(sortByCustomOrder(address, item => item.pmdMap, customAddressOrder))
: None,
payoutMethodData: pmd->Array.length > 0
? sortByCustomOrder(pmd, item => item.pmdMap, customPmdOrder)
: defaultDynamicPmdFields,
}
})
let decodePaymentMethodTypeWithRequiredFields = (
json: JSON.t,
defaultDynamicPmdFields: (~pmt: paymentMethodType=?) => array<dynamicFieldForPaymentMethodData>,
): option<(array<paymentMethodType>, array<paymentMethodTypeWithDynamicFields>)> =>
json
->JSON.Decode.object
->Option.flatMap(obj => {
let paymentMethod = obj->Dict.get("payment_method")->Option.flatMap(JSON.Decode.string)
obj
->Dict.get("payment_method_types_info")
->Option.flatMap(JSON.Decode.array)
->Option.map(pmtInfoArr =>
pmtInfoArr->Array.reduce(
([], []),
((pmta, pmtr), pmtInfo) =>
pmtInfo
->JSON.Decode.object
->Option.map(
obj => {
let paymentMethodType =
obj->Dict.get("payment_method_type")->Option.flatMap(JSON.Decode.string)
switch (paymentMethod, paymentMethodType) {
| (Some("card"), Some(cardType)) =>
cardType
->decodeCard
->Option.map(card => Card(card))
| (Some("bank_transfer"), Some(transferType)) =>
transferType
->decodeTransfer
->Option.map(transfer => BankTransfer(transfer))
| (Some("wallet"), Some(walletType)) =>
walletType
->decodeWallet
->Option.map(wallet => Wallet(wallet))
| _ => None
}
->Option.map(
pmt => {
let payoutDynamicFields =
obj
->Dict.get("required_fields")
->Option.flatMap(
json => json->decodePayoutDynamicFields(defaultDynamicPmdFields(~pmt)),
)
->Option.getOr({
address: None,
payoutMethodData: defaultDynamicPmdFields(~pmt),
})
switch pmt {
| Card(card) => {
pmta->Array.push(Card(card))
let pmtwr: paymentMethodTypeWithDynamicFields = Card(
card,
payoutDynamicFields,
)
pmtr->Array.push(pmtwr)
(pmta, pmtr)
}
| BankTransfer(transfer) => {
pmta->Array.push(BankTransfer(transfer))
pmtr->Array.push(BankTransfer(transfer, payoutDynamicFields))
(pmta, pmtr)
}
| Wallet(wallet) => {
let pmt: paymentMethodType = Wallet(wallet)
pmta->Array.push(pmt)
pmtr->Array.push(Wallet(wallet, payoutDynamicFields))
(pmta, pmtr)
}
}
},
)
->Option.getOr(([], []))
},
)
->Option.getOr(([], [])),
)
)
})
let decodePayoutConfirmResponse = (json: JSON.t): option<payoutConfirmResponse> => {
switch json->JSON.Decode.object {
| Some(obj) => {
let status = switch obj->Dict.get("status")->Option.flatMap(JSON.Decode.string) {
| Some("success") => Some(Success)
| Some("failed") => Some(Failed)
| Some("cancelled") => Some(Cancelled)
| Some("initiated") => Some(Initiated)
| Some("expired") => Some(Expired)
| Some("reversed") => Some(Reversed)
| Some("pending") => Some(Pending)
| Some("ineligible") => Some(Ineligible)
| Some("requires_creation") => Some(RequiresCreation)
| Some("requires_confirmation") => Some(RequiresConfirmation)
| Some("requires_payout_method_data") => Some(RequiresPayoutMethodData)
| Some("requires_fulfillment") => Some(RequiresFulfillment)
| Some("requires_vendor_account_creation") => Some(RequiresVendorAccountCreation)
| _ => None
}
// If status is found in the response, try to decode PayoutCreateResponse, else try to decode ErrorResponse
switch status {
| None =>
switch (
obj->Dict.get("type")->Option.flatMap(JSON.Decode.string),
obj->Dict.get("code")->Option.flatMap(JSON.Decode.string),
obj->Dict.get("message")->Option.flatMap(JSON.Decode.string),
obj->Dict.get("reason")->Option.flatMap(JSON.Decode.string),
) {
| (Some(errorType), Some(code), Some(message), reason) => {
let payoutFailureResponse = {
errorType,
code,
message,
reason,
}
Some(ErrorResponse(payoutFailureResponse))
}
| _ => None
}
| Some(status) =>
switch (
obj->Dict.get("payout_id")->Option.flatMap(JSON.Decode.string),
obj->Dict.get("merchant_id")->Option.flatMap(JSON.Decode.string),
obj->Dict.get("customer_id")->Option.flatMap(JSON.Decode.string),
obj->Dict.get("amount")->Option.flatMap(JSON.Decode.float),
obj->Dict.get("currency")->Option.flatMap(JSON.Decode.string),
obj->Dict.get("payout_type")->Option.flatMap(JSON.Decode.string),
obj->Dict.get("connector")->Option.flatMap(JSON.Decode.string),
obj->Dict.get("error_message")->Option.flatMap(JSON.Decode.string),
obj->Dict.get("error_code")->Option.flatMap(JSON.Decode.string),
obj->Dict.get("connector_transaction_id")->Option.flatMap(JSON.Decode.string),
) {
| (
Some(payoutId),
Some(merchantId),
Some(customerId),
Some(amount),
Some(currency),
Some(payoutType),
connector,
errorMessage,
errorCode,
connectorTransactionId,
) => {
let payoutSuccessResponse = {
payoutId,
merchantId,
customerId,
amount,
currency,
payoutType,
connector,
errorMessage,
errorCode,
connectorTransactionId,
status,
}
Some(SuccessResponse(payoutSuccessResponse))
}
| _ => None
}
}
}
| None => None
}
}
/**
* Expected JSON format
* [
* {
* "payment_method": "bank_transfer",
* "payment_method_types": [
{
"payment_method_type": "ach",
"required_fields": {
""
}
},
{
"payment_method_type": "bacs"
}
]
* },
* {
* "payment_method": "wallet",
* "payment_method_types": [
{
"payment_method_type": "paypal",
"required_fields": {
""
}
},
{
"payment_method_type": "venmo"
}
]
* },
* ]
*
* Decoded format - array<paymentMethodType>
*/
let decodePaymentMethodTypeArray = (
jsonArray: JSON.t,
defaultDynamicPmdFields: (~pmt: paymentMethodType=?) => array<dynamicFieldForPaymentMethodData>,
): (array<paymentMethodType>, array<paymentMethodTypeWithDynamicFields>) =>
switch JSON.Decode.array(jsonArray) {
| Some(items) =>
items
->Belt.Array.keepMap(decodePaymentMethodTypeWithRequiredFields(_, defaultDynamicPmdFields))
->Array.reduce(([], []), ((acc, accr), (pm, pmr)) => (
acc->Array.concat(pm),
accr->Array.concat(pmr),
))
| None => ([], [])
}
| 4,339 | 10,350 |
hyperswitch-web
|
src/Types/PaymentModeType.res
|
.res
|
type payment =
| Klarna
| Card
| Sofort
| AfterPay
| Affirm
| GiroPay
| Ideal
| EPS
| CryptoCurrency
| ACHTransfer
| SepaTransfer
| InstantTransfer
| BacsTransfer
| ACHBankDebit
| SepaBankDebit
| BacsBankDebit
| BecsBankDebit
| BanContactCard
| GooglePay
| ApplePay
| SamsungPay
| Boleto
| PayPal
| EFT
| NONE
let paymentMode = str => {
switch str {
| "card" => Card
| "klarna" => Klarna
| "afterpay_clearpay" => AfterPay
| "affirm" => Affirm
| "sofort" => Sofort
| "giropay" => GiroPay
| "ideal" => Ideal
| "eps" => EPS
| "crypto_currency" => CryptoCurrency
| "ach_debit" => ACHBankDebit
| "sepa_debit" => SepaBankDebit
| "bacs_debit" => BacsBankDebit
| "becs_debit" => BecsBankDebit
| "ach_transfer" => ACHTransfer
| "sepa_bank_transfer" => SepaTransfer
| "instant_bank_transfer" => InstantTransfer
| "bacs_transfer" => BacsTransfer
| "bancontact_card" => BanContactCard
| "google_pay" => GooglePay
| "apple_pay" => ApplePay
| "samsung_pay" => SamsungPay
| "boleto" => Boleto
| "paypal" => PayPal
| "eft" => EFT
| _ => NONE
}
}
let defaultOrder = [
"card",
"apple_pay",
"google_pay",
"paypal",
"klarna",
"samsung_pay",
"affirm",
"afterpay_clearpay",
"ach_transfer",
"sepa_bank_transfer",
"instant_bank_transfer",
"bacs_transfer",
"ach_debit",
"sepa_debit",
"bacs_debit",
"becs_debit",
"sofort",
"giropay",
"ideal",
"eps",
"crypto",
"bancontact_card",
"boleto",
"eft",
]
| 562 | 10,351 |
hyperswitch-web
|
src/Types/PaymentError.res
|
.res
|
open Utils
type error = {
type_: string,
code: string,
message: string,
}
type errorType = {error: error}
let defaultError = {
type_: "server_error",
code: "",
message: "Something went wrong",
}
let getError = (dict, str) => {
dict
->Dict.get(str)
->Option.flatMap(JSON.Decode.object)
->Option.map(json => {
{
type_: getString(json, "type", ""),
code: getString(json, "code", ""),
message: getString(json, "message", ""),
}
})
->Option.getOr(defaultError)
}
let itemToObjMapper = dict => {
{error: getError(dict, "error")}
}
| 158 | 10,352 |
hyperswitch-web
|
src/Types/PaypalSDKTypes.res
|
.res
|
type clientErr = bool
type clientInstance
type paypalCheckoutErr = {message: string}
type data
type order = {get: unit => promise<JSON.t>}
type actions = {order: order}
type err
type vault = {vault: bool}
type shipping = {
recipientName: option<string>,
line1: option<string>,
line2: option<string>,
city: option<string>,
countryCode: option<string>,
postalCode: option<string>,
state: option<string>,
phone: option<string>,
}
type details = {
email: string,
shippingAddress: shipping,
phone: option<string>,
}
type payload = {nonce: string, details: details}
type orderDetails = {
flow: string,
billingAgreementDescription: option<string>,
enableShippingAddress: option<bool>,
shippingAddressEditable: option<bool>,
shippingAddressOverride: option<shipping>,
}
let defaultShipping = {
recipientName: None,
line1: None,
line2: None,
city: None,
countryCode: None,
postalCode: None,
state: None,
phone: None,
}
let defaultOrderDetails = {
flow: "vault",
billingAgreementDescription: None,
enableShippingAddress: None,
shippingAddressEditable: None,
shippingAddressOverride: None,
}
type paypalCheckoutInstance = {
loadPayPalSDK: (vault, unit => unit) => unit,
createPayment: orderDetails => unit,
tokenizePayment: (data, (err, payload) => unit) => unit,
}
type authType = {authorization: string}
type checkoutClient = {client: clientInstance}
type client = {create: (authType, (clientErr, clientInstance) => unit) => unit}
type paypalCheckout = {
create: (checkoutClient, (Nullable.t<paypalCheckoutErr>, paypalCheckoutInstance) => unit) => unit,
}
type braintree = {
client: client,
paypalCheckout: paypalCheckout,
}
type funding = {"PAYPAL": string}
type style = {
layout: string,
color: string,
shape: string,
label: string,
height: int,
}
type buttons = {
style: style,
fundingSource: string,
createBillingAgreement?: unit => unit,
createOrder?: unit => promise<string>,
onApprove: (data, actions) => unit,
onCancel: data => unit,
onError?: err => unit,
onShippingAddressChange?: JSON.t => promise<JSON.t>,
}
let getLabel = (var: PaymentType.paypalStyleType) => {
switch var {
| Paypal => "paypal"
| Checkout => "checkout"
| Pay => "pay"
| Buynow => "buynow"
| Installment => "installment"
}
}
type some = {render: string => unit}
type paypal = {"Buttons": buttons => some, "FUNDING": funding}
@val external braintree: braintree = "braintree"
@val external paypal: paypal = "paypal"
let getShippingDetails = shippingAddressOverrideObj => {
let shippingAddressOverride = shippingAddressOverrideObj->Utils.getDictFromJson
let recipientName = shippingAddressOverride->Utils.getOptionString("recipient_name")
let line1 = shippingAddressOverride->Utils.getOptionString("line1")
let line2 = shippingAddressOverride->Utils.getOptionString("line2")
let city = shippingAddressOverride->Utils.getOptionString("city")
let countryCode = shippingAddressOverride->Utils.getOptionString("country_code")
let postalCode = shippingAddressOverride->Utils.getOptionString("postal_code")
let state = shippingAddressOverride->Utils.getOptionString("state")
let phone = shippingAddressOverride->Utils.getOptionString("phone")
if (
[recipientName, line1, line2, city, countryCode, postalCode, state, phone]->Array.includes(None)
) {
None
} else {
Some({
recipientName,
line1,
line2,
city,
countryCode,
postalCode,
state,
phone,
})
}
}
let paypalShippingDetails = (purchaseUnit, payerDetails: PaymentType.payerDetails) => {
let shippingAddress = purchaseUnit->Utils.getDictFromDict("shipping")
let address = shippingAddress->Utils.getDictFromDict("address")
let name = shippingAddress->Utils.getDictFromDict("name")
let recipientName = name->Utils.getOptionString("full_name")
let line1 = address->Utils.getOptionString("address_line_1")
let line2 = address->Utils.getOptionString("address_line_2")
let city = address->Utils.getOptionString("admin_area_2")
let countryCode = address->Utils.getOptionString("country_code")
let postalCode = address->Utils.getOptionString("postal_code")
let state = address->Utils.getOptionString("admin_area_1")
let email = payerDetails.email->Option.getOr("")
{
email,
shippingAddress: {
recipientName,
line1,
line2,
city,
countryCode,
postalCode,
state,
phone: payerDetails.phone,
},
phone: payerDetails.phone,
}
}
let getOrderDetails = (orderDetails, paymentType) => {
let orderDetailsDict = orderDetails->Utils.getDictFromJson
let isWalletElementPaymentType = paymentType->Utils.getIsWalletElementPaymentType
let shippingAddressOverride = isWalletElementPaymentType
? orderDetailsDict->Utils.getJsonObjectFromDict("shipping_address_override")->getShippingDetails
: None
let enableShippingAddress = isWalletElementPaymentType
? orderDetailsDict->Utils.getOptionBool("enable_shipping_address")
: None
{
flow: orderDetailsDict->Utils.getString("flow", "vault"),
billingAgreementDescription: None,
enableShippingAddress,
shippingAddressEditable: None,
shippingAddressOverride,
}
}
let shippingAddressItemToObjMapper = dict => {
recipientName: dict->Utils.getOptionString("recipientName"),
line1: dict->Utils.getOptionString("line1"),
line2: dict->Utils.getOptionString("line2"),
city: dict->Utils.getOptionString("city"),
countryCode: dict->Utils.getOptionString("countryCode"),
postalCode: dict->Utils.getOptionString("postalCode"),
state: dict->Utils.getOptionString("state"),
phone: dict->Utils.getOptionString("phone"),
}
| 1,405 | 10,353 |
hyperswitch-web
|
src/Types/SessionsType.res
|
.res
|
open Utils
type wallet = Gpay | Paypal | Klarna | ApplePay | SamsungPay | Paze | ClickToPay | NONE
type tokenCategory =
| ApplePayObject
| GooglePayThirdPartyObject
| SamsungPayObject
| PazeObject
| ClickToPayObject
| Others
type paymentType = Wallet | Others
type token = {
walletName: wallet,
token: string,
sessionId: string,
allowed_payment_methods: array<JSON.t>,
transaction_info: JSON.t,
merchant_info: JSON.t,
shippingAddressRequired: bool,
emailRequired: bool,
shippingAddressParameters: JSON.t,
orderDetails: JSON.t,
connector: string,
clientId: string,
clientName: string,
clientProfileId: string,
email_address: string,
transaction_amount: string,
transaction_currency_code: string,
}
type tokenType =
| ApplePayToken(array<JSON.t>)
| GooglePayThirdPartyToken(array<JSON.t>)
| PazeToken(array<JSON.t>)
| SamsungPayToken(array<JSON.t>)
| ClickToPayToken(array<JSON.t>)
| OtherToken(array<token>)
type optionalTokenType =
| ApplePayTokenOptional(option<JSON.t>)
| GooglePayThirdPartyTokenOptional(option<JSON.t>)
| PazeTokenOptional(option<JSON.t>)
| SamsungPayTokenOptional(option<JSON.t>)
| ClickToPayTokenOptional(option<JSON.t>)
| OtherTokenOptional(option<token>)
type sessions = {
paymentId: string,
clientSecret: string,
sessionsToken: tokenType,
}
let defaultToken = {
walletName: NONE,
token: "",
sessionId: "",
allowed_payment_methods: [],
transaction_info: Dict.make()->JSON.Encode.object,
merchant_info: Dict.make()->JSON.Encode.object,
shippingAddressRequired: false,
emailRequired: false,
shippingAddressParameters: Dict.make()->JSON.Encode.object,
orderDetails: Dict.make()->JSON.Encode.object,
connector: "",
clientId: "",
clientName: "",
clientProfileId: "",
email_address: "",
transaction_amount: "",
transaction_currency_code: "",
}
let getWallet = str => {
switch str {
| "apple_pay" => ApplePay
| "paypal" => Paypal
| "klarna" => Klarna
| "samsung_pay" => SamsungPay
| "google_pay" => Gpay
| "paze" => Paze
| "click_to_pay" => ClickToPay
| _ => NONE
}
}
let getSessionsToken = (dict, str) =>
dict
->Dict.get(str)
->Option.flatMap(JSON.Decode.array)
->Option.map(arr => {
arr->Array.map(json => {
let dict = json->getDictFromJson
{
walletName: getString(dict, "wallet_name", "")->getWallet,
token: getString(dict, "session_token", ""),
sessionId: getString(dict, "session_id", ""),
allowed_payment_methods: getArray(dict, "allowed_payment_methods"),
transaction_info: getJsonObjectFromDict(dict, "transaction_info"),
merchant_info: getJsonObjectFromDict(dict, "merchant_info"),
shippingAddressRequired: getBool(dict, "shipping_address_required", false),
emailRequired: getBool(dict, "email_required", false),
shippingAddressParameters: getJsonObjectFromDict(dict, "shipping_address_parameters"),
orderDetails: getJsonObjectFromDict(dict, "order_details"),
connector: getString(dict, "connector", ""),
clientId: getString(dict, "client_id", ""),
clientName: getString(dict, "client_name", ""),
clientProfileId: getString(dict, "client_profile_id", ""),
email_address: getString(dict, "email_address", ""),
transaction_amount: getString(dict, "transaction_amount", ""),
transaction_currency_code: getString(dict, "transaction_currency_code", ""),
}
})
})
->Option.getOr([defaultToken])
let getSessionsTokenJson = (dict, str) =>
dict->Dict.get(str)->Option.flatMap(JSON.Decode.array)->Option.getOr([])
let itemToObjMapper = (dict, returnType) => {
switch returnType {
| ApplePayObject => {
paymentId: getString(dict, "payment_id", ""),
clientSecret: getString(dict, "client_secret", ""),
sessionsToken: ApplePayToken(getSessionsTokenJson(dict, "session_token")),
}
| GooglePayThirdPartyObject => {
paymentId: getString(dict, "payment_id", ""),
clientSecret: getString(dict, "client_secret", ""),
sessionsToken: GooglePayThirdPartyToken(getSessionsTokenJson(dict, "session_token")),
}
| PazeObject => {
paymentId: getString(dict, "payment_id", ""),
clientSecret: getString(dict, "client_secret", ""),
sessionsToken: PazeToken(getSessionsTokenJson(dict, "session_token")),
}
| SamsungPayObject => {
paymentId: getString(dict, "payment_id", ""),
clientSecret: getString(dict, "client_secret", ""),
sessionsToken: SamsungPayToken(getSessionsTokenJson(dict, "session_token")),
}
| ClickToPayObject => {
paymentId: getString(dict, "payment_id", ""),
clientSecret: getString(dict, "client_secret", ""),
sessionsToken: ClickToPayToken(getSessionsTokenJson(dict, "session_token")),
}
| Others => {
paymentId: getString(dict, "payment_id", ""),
clientSecret: getString(dict, "client_secret", ""),
sessionsToken: OtherToken(getSessionsToken(dict, "session_token")),
}
}
}
let getWalletFromTokenType = (arr, val) =>
arr->Array.find(item =>
item
->JSON.Decode.object
->Option.flatMap(x => x->Dict.get("wallet_name"))
->Option.flatMap(JSON.Decode.string)
->Option.getOr("")
->getWallet === val
)
let getPaymentSessionObj = (tokenType, val) =>
switch tokenType {
| ApplePayToken(arr) => ApplePayTokenOptional(getWalletFromTokenType(arr, val))
| GooglePayThirdPartyToken(arr) =>
GooglePayThirdPartyTokenOptional(getWalletFromTokenType(arr, val))
| PazeToken(arr) => PazeTokenOptional(getWalletFromTokenType(arr, val))
| SamsungPayToken(arr) => SamsungPayTokenOptional(getWalletFromTokenType(arr, val))
| ClickToPayToken(arr) => ClickToPayTokenOptional(getWalletFromTokenType(arr, val))
| OtherToken(arr) => OtherTokenOptional(arr->Array.find(item => item.walletName == val))
}
| 1,427 | 10,354 |
hyperswitch-web
|
src/Types/RecoilAtomTypes.res
|
.res
|
type field = {
value: string,
isValid: option<bool>,
errorString: string,
countryCode?: string,
}
type load = Loading | Loaded(JSON.t) | LoadError
type paymentToken = {
paymentToken: string,
customerId: string,
}
type redirectionFlags = {
shouldUseTopRedirection: bool,
shouldRemoveBeforeUnloadEvents: bool,
}
let decodeRedirectionFlags = (json: JSON.t, default: redirectionFlags): redirectionFlags => {
json
->JSON.Decode.object
->Option.flatMap(obj => {
let shouldUseTopRedirection =
obj
->Dict.get("shouldUseTopRedirection")
->Option.flatMap(JSON.Decode.bool)
->Option.getOr(default.shouldUseTopRedirection)
let shouldRemoveBeforeUnloadEvents =
obj
->Dict.get("shouldRemoveBeforeUnloadEvents")
->Option.flatMap(JSON.Decode.bool)
->Option.getOr(default.shouldRemoveBeforeUnloadEvents)
Some({
shouldRemoveBeforeUnloadEvents,
shouldUseTopRedirection,
})
})
->Option.getOr(default)
}
| 231 | 10,355 |
hyperswitch-web
|
src/Types/SamsungPayType.res
|
.res
|
type client = {
isReadyToPay: JSON.t => promise<JSON.t>,
createButton: JSON.t => Dom.element,
loadPaymentSheet: (JSON.t, JSON.t) => promise<Fetch.Response.t>,
notify: JSON.t => unit,
}
type env = {environment: string}
@new external samsung: env => client = "SamsungPay.PaymentClient"
type merchant = {
name: string,
url: string,
countryCode: string,
}
type amount = {
option: string,
currency: string,
total: string,
}
type transactionDetail = {
orderNumber: string,
merchant: merchant,
amount: amount,
}
type paymentMethods = {
version: string,
serviceId: string,
protocol: string,
allowedBrands: array<string>,
}
type threeDS = {
\"type": string,
version: string,
data: string,
}
type paymentMethodData = {
method: string,
recurring_payment: bool,
card_brand: string,
card_last4digits: string,
@as("3_d_s") threeDS: threeDS,
}
type paymentData = {paymentMethodData: paymentMethodData}
| 252 | 10,356 |
hyperswitch-web
|
src/Types/ApplePayTypes.res
|
.res
|
open Utils
type token = {paymentData: JSON.t}
type billingContact = {
addressLines: array<string>,
administrativeArea: string,
countryCode: string,
familyName: string,
givenName: string,
locality: string,
postalCode: string,
}
type shippingContact = {
emailAddress: string,
phoneNumber: string,
addressLines: array<string>,
administrativeArea: string,
countryCode: string,
familyName: string,
givenName: string,
locality: string,
postalCode: string,
}
type paymentResult = {token: JSON.t, billingContact: JSON.t, shippingContact: JSON.t}
type event = {validationURL: string, payment: paymentResult}
type lineItem = {
label: string,
amount: string,
\"type": string,
}
type shippingAddressChangeEvent = {shippingContact: JSON.t}
type orderDetails = {newTotal: lineItem, newLineItems: array<lineItem>}
type innerSession
type session = {
begin: unit => unit,
abort: unit => unit,
mutable oncancel: unit => unit,
canMakePayments: unit => bool,
mutable onvalidatemerchant: event => unit,
completeMerchantValidation: JSON.t => unit,
mutable onpaymentauthorized: event => unit,
mutable onshippingcontactselected: shippingAddressChangeEvent => promise<unit>,
completeShippingContactSelection: orderDetails => unit,
completePayment: JSON.t => unit,
\"STATUS_SUCCESS": string,
\"STATUS_FAILURE": string,
}
type applePaySession
type window = {\"ApplePaySession": applePaySession}
@val external window: window = "window"
@scope("window") @val external sessionForApplePay: Nullable.t<session> = "ApplePaySession"
@new external applePaySession: (int, JSON.t) => session = "ApplePaySession"
@deriving(abstract)
type total = {
label: string,
@optional \"type": string,
amount: string,
}
type sdkNextAction = {nextAction: string}
@deriving(abstract)
type paymentRequestData = {
countryCode: string,
currencyCode: string,
total: total,
merchantCapabilities: array<string>,
supportedNetworks: array<string>,
@optional merchantIdentifier: string,
}
type headlessApplePayToken = {
paymentRequestData: JSON.t,
sessionTokenData: option<JSON.t>,
}
let defaultHeadlessApplePayToken: headlessApplePayToken = {
paymentRequestData: JSON.Encode.null,
sessionTokenData: None,
}
let jsonToPaymentRequestDataType: Dict.t<JSON.t> => paymentRequestData = jsonDict => {
let clientTimeZone = CardUtils.dateTimeFormat().resolvedOptions().timeZone
let clientCountry = getClientCountry(clientTimeZone)
let defaultCountryCode = clientCountry.isoAlpha2
let getTotal = totalDict => {
getString(totalDict, "type", "") == ""
? total(
~label=getString(totalDict, "label", ""),
~amount=getString(totalDict, "amount", ""),
(),
)
: total(
~label=getString(totalDict, "label", ""),
~amount=getString(totalDict, "amount", ""),
~\"type"=getString(totalDict, "type", ""),
(),
)
}
if getString(jsonDict, "merchant_identifier", "") == "" {
paymentRequestData(
~countryCode=getString(jsonDict, "country_code", defaultCountryCode),
~currencyCode=getString(jsonDict, "currency_code", ""),
~merchantCapabilities=getStrArray(jsonDict, "merchant_capabilities"),
~supportedNetworks=getStrArray(jsonDict, "supported_networks"),
~total=getTotal(jsonDict->getDictFromObj("total")),
(),
)
} else {
paymentRequestData(
~countryCode=getString(jsonDict, "country_code", ""),
~currencyCode=getString(jsonDict, "currency_code", ""),
~merchantCapabilities=getStrArray(jsonDict, "merchant_capabilities"),
~supportedNetworks=getStrArray(jsonDict, "supported_networks"),
~total=getTotal(jsonDict->getDictFromObj("total")),
~merchantIdentifier=getString(jsonDict, "merchant_identifier", ""),
(),
)
}
}
let billingContactItemToObjMapper = dict => {
{
addressLines: dict->getStrArray("addressLines"),
administrativeArea: dict->getString("administrativeArea", ""),
countryCode: dict->getString("countryCode", ""),
familyName: dict->getString("familyName", ""),
givenName: dict->getString("givenName", ""),
locality: dict->getString("locality", ""),
postalCode: dict->getString("postalCode", ""),
}
}
let shippingContactItemToObjMapper = dict => {
{
emailAddress: dict->getString("emailAddress", ""),
phoneNumber: dict->getString("phoneNumber", ""),
addressLines: dict->getStrArray("addressLines"),
administrativeArea: dict->getString("administrativeArea", ""),
countryCode: dict->getString("countryCode", ""),
familyName: dict->getString("familyName", ""),
givenName: dict->getString("givenName", ""),
locality: dict->getString("locality", ""),
postalCode: dict->getString("postalCode", ""),
}
}
let getPaymentRequestFromSession = (~sessionObj, ~componentName) => {
let paymentRequest =
sessionObj
->Option.flatMap(JSON.Decode.object)
->Option.getOr(Dict.make())
->Dict.get("payment_request_data")
->Option.getOr(Dict.make()->JSON.Encode.object)
->transformKeys(CamelCase)
let requiredShippingContactFields =
paymentRequest
->getDictFromJson
->getStrArray("requiredShippingContactFields")
if (
componentName->getIsExpressCheckoutComponent->not &&
requiredShippingContactFields->Array.length !== 0
) {
let shippingFieldsWithoutPostalAddress =
requiredShippingContactFields->Array.filter(item => item !== "postalAddress")
paymentRequest
->getDictFromJson
->Dict.set(
"requiredShippingContactFields",
shippingFieldsWithoutPostalAddress
->getArrofJsonString
->JSON.Encode.array,
)
}
paymentRequest
}
| 1,343 | 10,357 |
hyperswitch-web
|
src/Types/ClickToPayHelpers.res
|
.res
|
open Promise
let scriptId = "mastercard-external-script"
let getScriptSrc = (isProd: bool) => {
let clickToPayMastercardBaseUrl = isProd
? "https://src.mastercard.com"
: "https://sandbox.src.mastercard.com"
clickToPayMastercardBaseUrl ++ "/srci/integration/2/lib.js"
}
let srcUiKitScriptSrc = "https://src.mastercard.com/srci/integration/components/src-ui-kit/src-ui-kit.esm.js"
let srcUiKitCssHref = "https://src.mastercard.com/srci/integration/components/src-ui-kit/src-ui-kit.css"
let recognitionTokenCookieName = "__mastercard_click_to_pay"
let manualCardId = "click_to_pay_manual_card"
let savedCardId = "click_to_pay_saved_card_"
let orderIdRef = ref("")
type element = {
mutable innerHTML: string,
appendChild: CommonHooks.element => unit,
removeChild: CommonHooks.element => unit,
replaceChildren: unit => unit,
children: array<CommonHooks.element>,
}
type elementDocument
@val external myDocument: elementDocument = "document"
@send external getElementById: (elementDocument, string) => Nullable.t<element> = "getElementById"
open Window
let clickToPayWindowRef: ref<Nullable.t<window>> = ref(Nullable.null)
let handleCloseClickToPayWindow = () => {
switch clickToPayWindowRef.contents->Nullable.toOption {
| Some(window) => {
window->closeWindow
clickToPayWindowRef.contents = Nullable.null
}
| None => ()
}
}
let handleOpenClickToPayWindow = () => {
clickToPayWindowRef.contents = windowOpen("", "ClickToPayWindow", "width=480,height=600")
}
// Global window extensions
type mastercardCheckoutServices
@val
external mastercardCheckoutServices: mastercardCheckoutServices =
"window.MastercardCheckoutServices"
// Response types
type responsePayloadStatus = COMPLETE | CANCEL | PAY_V3_CARD | ERROR
type responsePayload = {
status: responsePayloadStatus,
payload: JSON.t,
}
type cardBrand = [
| #visa
| #mastercard
| #discover
| #amex
]
type authenticationPreferences = {payloadRequested: [#AUTHENTICATED | #NON_AUTHENTICATED]}
type paymentOption = {
dpaDynamicDataTtlMinutes: int,
dynamicDataType: [#CARD_APPLICATION_CRYPTOGRAM_SHORT_FORM | #NONE],
}
type transactionAmount = {
transactionAmount: float,
transactionCurrencyCode: string,
}
type dpaTransactionOptions = {
dpaLocale: string,
authenticationPreferences: authenticationPreferences,
paymentOptions: array<paymentOption>,
transactionAmount: transactionAmount,
acquirerBIN: string,
acquirerMerchantId: string,
merchantCategoryCode: string,
merchantCountryCode: string,
}
type dpaData = {dpaName: string}
type params = {
srcDpaId: string,
dpaData: dpaData,
dpaTransactionOptions: dpaTransactionOptions,
cardBrands: array<string>,
recognitionToken?: string,
checkoutExperience: [#WITHIN_CHECKOUT | #PAYMENT_SETTINGS],
}
type country = {
code: string,
countryISO: string,
}
let defaultCountry: country = {code: "", countryISO: ""}
// Cookie helpers
@val external document: {..} = "document"
let setLocalStorage = (~key: string, ~value: string) => {
Window.LocalStorage.setItem(key, value)
}
let getLocalStorage = (~key: string) => {
Window.LocalStorage.getItem(key)
}
let deleteLocalStorage = (~key: string) => {
Window.LocalStorage.removeItem(key)
}
type mobileNumber = {
phoneNumber: string,
countryCode: string,
}
type savedCardInfo = {
panBin: string,
cardBrand: string,
}
type identityType = EMAIL_ADDRESS | MOBILE_PHONE_NUMBER
let getIdentityType = identityType => {
switch identityType {
| EMAIL_ADDRESS => "EMAIL_ADDRESS"
| MOBILE_PHONE_NUMBER => "MOBILE_PHONE_NUMBER"
}
}
type consumerIdentity = {
identityType: identityType,
identityValue: string,
}
type accountReference = {consumerIdentity: consumerIdentity}
type authenticatePayload = {
windowRef: window,
requestRecognitionToken: bool,
accountReference: accountReference,
}
type encryptCardPayload = {
primaryAccountNumber: string,
panExpirationMonth: string,
panExpirationYear: string,
cardSecurityCode: string,
}
type checkoutWithCardPayload = {
windowRef: window,
srcDigitalCardId: string,
rememberMe: bool,
}
type digitalCardData = {descriptorName: string}
type clickToPayCard = {
srcDigitalCardId: string,
panLastFour: string,
panExpirationMonth: string,
panExpirationYear: string,
paymentCardDescriptor: string,
digitalCardData: digitalCardData,
panBin: string,
}
let clickToPayCardItemToObjMapper = (json: JSON.t): clickToPayCard => {
let dict = json->Utils.getDictFromJson
{
srcDigitalCardId: dict->Utils.getString("srcDigitalCardId", ""),
panLastFour: dict->Utils.getString("panLastFour", ""),
panExpirationMonth: dict->Utils.getString("panExpirationMonth", ""),
panExpirationYear: dict->Utils.getString("panExpirationYear", ""),
paymentCardDescriptor: dict->Utils.getString("paymentCardDescriptor", ""),
digitalCardData: {
descriptorName: dict
->Utils.getDictFromDict("digitalCardData")
->Utils.getString("descriptorName", ""),
},
panBin: dict->Utils.getString("panBin", ""),
}
}
type clickToPayToken = {
dpaId: string,
dpaName: string,
locale: string,
transactionAmount: float,
transactionCurrencyCode: string,
acquirerBIN: string,
acquirerMerchantId: string,
merchantCategoryCode: string,
merchantCountryCode: string,
cardBrands: array<string>,
email: string,
}
let clickToPayTokenItemToObjMapper = (json: JSON.t) => {
let dict = json->Utils.getDictFromJson
{
dpaId: dict->Utils.getString("dpa_id", ""),
dpaName: dict->Utils.getString("dpa_name", ""),
locale: dict->Utils.getString("locale", ""),
transactionAmount: dict->Utils.getFloat("transaction_amount", 0.0),
transactionCurrencyCode: dict->Utils.getString("transaction_currency_code", ""),
acquirerBIN: dict->Utils.getString("acquirer_bin", ""),
acquirerMerchantId: dict->Utils.getString("acquirer_merchant_id", ""),
merchantCategoryCode: dict->Utils.getString("merchant_category_code", ""),
merchantCountryCode: dict->Utils.getString("merchant_country_code", ""),
cardBrands: dict
->Utils.getArray("card_brands")
->Array.map(item => item->JSON.Decode.string->Option.getOr("")),
email: dict->Utils.getString("email", ""),
}
}
// Update the previously defined mastercardCheckoutServices type
@send
external getCards: (mastercardCheckoutServices, unit) => promise<array<clickToPayCard>> = "getCards"
@send
external authenticate: (mastercardCheckoutServices, authenticatePayload) => promise<JSON.t> =
"authenticate"
@send
external checkoutWithCard: (
mastercardCheckoutServices,
checkoutWithCardPayload,
) => promise<JSON.t> = "checkoutWithCard"
@send
external encryptCard: (mastercardCheckoutServices, encryptCardPayload) => promise<JSON.t> =
"encryptCard"
type consumer = {
emailAddress: string,
mobileNumber: mobileNumber,
}
type complianceSettingsData = {
acceptedVersion: string,
latestVersion: string,
latestVersionUri: string,
}
type complianceSettings = {
privacy: complianceSettingsData,
tnc: complianceSettingsData,
cookie: complianceSettingsData,
}
// Add the CheckoutWithNewCardPayload type
type checkoutWithNewCardPayload = {
windowRef: window,
cardBrand: string,
encryptedCard: JSON.t,
rememberMe: bool,
consumer?: consumer,
complianceSettings: complianceSettings,
}
let mcCheckoutService: ref<option<mastercardCheckoutServices>> = ref(None)
// First, let's add the ClickToPayOptions type
type clickToPayOptions = {
dpaId: string,
dpaName: string,
locale?: string,
transactionAmount: float,
transactionCurrencyCode: string,
acquirerBIN: string,
acquirerMerchantId: string,
merchantCategoryCode: string,
merchantCountryCode: string,
cardBrands: array<string>,
}
// Add the init external
@send
external init: (mastercardCheckoutServices, params) => promise<JSON.t> = "init"
// First add this external to check window property
@val @scope("window")
external getOptionMastercardCheckoutServices: option<unit => mastercardCheckoutServices> =
"MastercardCheckoutServices"
@new @scope("window")
external getMastercardCheckoutServices: unit => mastercardCheckoutServices =
"MastercardCheckoutServices"
// Then update the initialization function
let initializeMastercardCheckout = (
clickToPayToken: clickToPayToken,
logger: HyperLogger.loggerMake,
) => {
switch getOptionMastercardCheckoutServices {
| Some(_) => {
logger.setLogInfo(
~value="MastercardCheckoutServices constructor found",
~eventName=CLICK_TO_PAY_FLOW,
)
// Create new instance by calling the constructor
mcCheckoutService := Some(getMastercardCheckoutServices())
// Get recognition token
let recognitionToken = getLocalStorage(~key=recognitionTokenCookieName)
logger.setLogInfo(~value="Recognition token fetched", ~eventName=CLICK_TO_PAY_FLOW)
// Construct params
let params = {
srcDpaId: clickToPayToken.dpaId,
dpaData: {
dpaName: clickToPayToken.dpaName,
},
dpaTransactionOptions: {
dpaLocale: clickToPayToken.locale,
authenticationPreferences: {
payloadRequested: #AUTHENTICATED,
},
paymentOptions: [
{
dpaDynamicDataTtlMinutes: 15,
dynamicDataType: #CARD_APPLICATION_CRYPTOGRAM_SHORT_FORM,
},
],
transactionAmount: {
transactionAmount: clickToPayToken.transactionAmount,
transactionCurrencyCode: clickToPayToken.transactionCurrencyCode,
},
acquirerBIN: clickToPayToken.acquirerBIN,
acquirerMerchantId: clickToPayToken.acquirerMerchantId,
merchantCategoryCode: clickToPayToken.merchantCategoryCode,
merchantCountryCode: clickToPayToken.merchantCountryCode,
},
checkoutExperience: #WITHIN_CHECKOUT,
cardBrands: clickToPayToken.cardBrands,
}
// Add recognition token if exists
let params = switch recognitionToken->Nullable.toOption {
| Some(token) => {...params, recognitionToken: token}
| None => params
}
try {
switch mcCheckoutService.contents {
| Some(service) => {
logger.setLogInfo(
~value="Mastercard Checkout Service initialized",
~eventName=CLICK_TO_PAY_FLOW,
)
service
->init(params)
->then(resp => {
logger.setLogInfo(
~value="Mastercard Checkout initialized",
~eventName=CLICK_TO_PAY_FLOW,
)
resolve(resp)
})
->catch(err => {
logger.setLogError(
~value=`Error initializing Mastercard Checkout - ${err
->Utils.formatException
->JSON.stringify}`,
~eventName=CLICK_TO_PAY_FLOW,
)
reject(err)
})
}
| None => {
logger.setLogError(
~value="Mastercard Checkout Service not initialized",
~eventName=CLICK_TO_PAY_FLOW,
)
reject(Exn.anyToExnInternal("Mastercard Checkout Service not initialized"))
}
}
} catch {
| error => {
logger.setLogError(
~value=`Error initializing Mastercard Checkout - ${error
->Utils.formatException
->JSON.stringify}`,
~eventName=CLICK_TO_PAY_FLOW,
)
reject(error)
}
}
}
| None => {
logger.setLogError(
~value="MastercardCheckoutServices is not available",
~eventName=CLICK_TO_PAY_FLOW,
)
reject(Exn.anyToExnInternal("MastercardCheckoutServices is not available"))
}
}
}
let getCards = async (logger: HyperLogger.loggerMake) => {
try {
switch mcCheckoutService.contents {
| Some(service) => {
let cards = await service->getCards()
logger.setLogInfo(~value="Cards returned from API", ~eventName=CLICK_TO_PAY_FLOW)
Ok(cards)
}
| None => {
logger.setLogError(
~value="Mastercard Checkout Service not initialized",
~eventName=CLICK_TO_PAY_FLOW,
)
Ok([])
}
}
} catch {
| error => {
logger.setLogError(
~value=`Error getting cards - ${error->Utils.formatException->JSON.stringify}`,
~eventName=CLICK_TO_PAY_FLOW,
)
Ok([])
}
}
}
// First, let's define the AuthenticatePayload type
type authenticateInputPayload = {
windowRef: window,
consumerIdentity: consumerIdentity,
}
// Add this external for getting hostname
@val @scope(("window", "location"))
external hostname: string = "hostname"
let authenticate = async (payload: authenticateInputPayload, logger: HyperLogger.loggerMake) => {
// Construct the authenticate payload
let authenticatePayload = {
windowRef: payload.windowRef,
requestRecognitionToken: true,
accountReference: {
consumerIdentity: {
identityType: payload.consumerIdentity.identityType,
identityValue: payload.consumerIdentity.identityValue,
},
},
}
try {
switch mcCheckoutService.contents {
| Some(service) => {
let authentication = await service->authenticate(authenticatePayload)
// Check and set recognition token if present
let recognitionToken =
authentication->Utils.getDictFromJson->Utils.getString("recognitionToken", "")
if recognitionToken !== "" {
setLocalStorage(~key=recognitionTokenCookieName, ~value=recognitionToken)
}
Ok(authentication)
}
| None => {
logger.setLogError(
~value="Mastercard Checkout Service not initialized",
~eventName=CLICK_TO_PAY_FLOW,
)
Error(Exn.anyToExnInternal("Mastercard Checkout Service not initialized"))
}
}
} catch {
| error => {
logger.setLogError(
~value=`Error during authentication - ${error->Utils.formatException->JSON.stringify}`,
~eventName=CLICK_TO_PAY_FLOW,
)
Error(error)
}
}
}
let checkoutWithCard = async (
~windowRef: window,
~srcDigitalCardId: string,
~logger: HyperLogger.loggerMake,
) => {
let checkoutPayload = {
windowRef,
srcDigitalCardId,
rememberMe: true,
}
try {
switch mcCheckoutService.contents {
| Some(service) => {
let checkoutResp = await service->checkoutWithCard(checkoutPayload)
Ok(checkoutResp)
}
| None => {
logger.setLogError(
~value="Mastercard Checkout Service not initialized",
~eventName=CLICK_TO_PAY_FLOW,
)
Error(Exn.anyToExnInternal("Mastercard Checkout Service not initialized"))
}
}
} catch {
| error => {
logger.setLogError(
~value=`Error during checkout with card - ${error->Utils.formatException->JSON.stringify}`,
~eventName=CLICK_TO_PAY_FLOW,
)
Error(error)
}
}
}
let encryptCardForClickToPay = async (
~cardNumber,
~expiryMonth,
~expiryYear,
~cvcNumber,
~logger: HyperLogger.loggerMake,
) => {
let card: encryptCardPayload = {
primaryAccountNumber: cardNumber,
panExpirationMonth: expiryMonth,
panExpirationYear: expiryYear,
cardSecurityCode: cvcNumber,
}
try {
switch mcCheckoutService.contents {
| Some(service) => {
logger.setLogInfo(~value="Encrypting card for Click to Pay", ~eventName=CLICK_TO_PAY_FLOW)
let encryptedCard = await service->encryptCard(card)
Ok(encryptedCard)
}
| None => {
logger.setLogError(
~value="Mastercard Checkout Service not initialized",
~eventName=CLICK_TO_PAY_FLOW,
)
Error(Exn.anyToExnInternal("Mastercard Checkout Service not initialized"))
}
}
} catch {
| error => {
logger.setLogError(
~value=`Error encrypting card - ${error->Utils.formatException->JSON.stringify}`,
~eventName=CLICK_TO_PAY_FLOW,
)
Error(error)
}
}
}
@send
external checkoutWithNewCard: (
mastercardCheckoutServices,
checkoutWithNewCardPayload,
) => promise<JSON.t> = "checkoutWithNewCard"
let checkoutWithNewCard = async (
payload: checkoutWithNewCardPayload,
~logger: HyperLogger.loggerMake,
) => {
try {
switch mcCheckoutService.contents {
| Some(service) => {
let checkoutResp = await service->checkoutWithNewCard(payload->Obj.magic)
Ok(checkoutResp)
}
| None => {
logger.setLogError(
~value="Mastercard Checkout Service not initialized",
~eventName=CLICK_TO_PAY_FLOW,
)
Error(Exn.anyToExnInternal("Mastercard Checkout Service not initialized"))
}
}
} catch {
| error => {
logger.setLogError(
~value=`Error during checkout with new card - ${error
->Utils.formatException
->JSON.stringify}`,
~eventName=CLICK_TO_PAY_FLOW,
)
Error(error)
}
}
}
// Add these externals at the top with other DOM-related externals
@val @scope("document")
external querySelector: string => Nullable.t<Dom.element> = "querySelector"
@val @scope("document")
external createElement: string => Dom.element = "createElement"
@val @scope(("document", "head"))
external appendChild: Dom.element => unit = "appendChild"
@set external setType: (Dom.element, string) => unit = "type"
@set external setSrc: (Dom.element, string) => unit = "src"
@set external setRel: (Dom.element, string) => unit = "rel"
@set external setHref: (Dom.element, string) => unit = "href"
@set external setOnload: (Dom.element, unit => unit) => unit = "onload"
@val @scope(("top", "location"))
external topLocationHref: string = "href"
// Add these externals for script events
@set external setOnLoad: (Dom.element, unit => unit) => unit = "onload"
@set external setOnError: (Dom.element, unit => unit) => unit = "onerror"
// Add the function at the end of the file
let loadClickToPayScripts = (logger: HyperLogger.loggerMake) => {
Promise.make((clickToPayScriptsPromiseResolve, _) => {
let scriptSelector = `script[src="${srcUiKitScriptSrc}"]`
let linkSelector = `link[href="${srcUiKitCssHref}"]`
// Add script if not exists
let srcUiKitScriptPromise = Promise.make((scriptPromiseResolve, _) => {
switch querySelector(scriptSelector)->Nullable.toOption {
| None => {
let script = createElement("script")
script->setType("module")
script->setSrc(srcUiKitScriptSrc)
script->setOnLoad(
() => {
logger.setLogInfo(
~value="ClickToPay UI Kit Script Loaded",
~eventName=CLICK_TO_PAY_SCRIPT,
)
scriptPromiseResolve()
},
)
appendChild(script)
}
| Some(_) => scriptPromiseResolve()
}
})
// Add link if not exists
let srcUiKitCssPromise = Promise.make((cssPromiseResolve, _) => {
switch querySelector(linkSelector)->Nullable.toOption {
| None => {
let link = createElement("link")
link->setRel("stylesheet")
link->setHref(srcUiKitCssHref)
link->setOnLoad(
() => {
logger.setLogInfo(
~value="ClickToPay UI Kit CSS Loaded",
~eventName=CLICK_TO_PAY_SCRIPT,
)
cssPromiseResolve()
},
)
appendChild(link)
}
| Some(_) => cssPromiseResolve()
}
})
Promise.all([srcUiKitScriptPromise, srcUiKitCssPromise])
->then(_ => {
clickToPayScriptsPromiseResolve()
resolve()
})
->catch(_ => {
logger.setLogError(~value="ClickToPay UI Kit CSS Load Error", ~eventName=CLICK_TO_PAY_SCRIPT)
resolve()
})
->ignore
})
}
// Add this function at the end of the file
let loadMastercardScript = (clickToPayToken, isProd, logger: HyperLogger.loggerMake) => {
let scriptSrc = isProd->getScriptSrc
Promise.make((resolve, reject) => {
let scriptSelector = `script[src="${scriptSrc}"]`
switch querySelector(scriptSelector)->Nullable.toOption {
| Some(_) => {
logger.setLogInfo(~value="Mastercard Script Already Exists", ~eventName=CLICK_TO_PAY_SCRIPT)
// Script already exists, just initialize
initializeMastercardCheckout(clickToPayToken, logger)
->then(resp => {
resp->resolve
Promise.resolve()
})
->catch(err => {
err->reject
Promise.resolve()
})
->ignore
}
| None => {
let script = createElement("script")
script->setType("text/javascript")
script->setSrc(scriptSrc)
// Set onload handler
script->setOnLoad(() => {
logger.setLogInfo(
~value="Script loaded, initializing Mastercard Checkout",
~eventName=CLICK_TO_PAY_SCRIPT,
)
// Initialize after script loads
initializeMastercardCheckout(clickToPayToken, logger)
->then(
resp => {
resp->resolve
Promise.resolve()
},
)
->catch(
err => {
err->reject
Promise.resolve()
},
)
->ignore
})
// Set onerror handler
script->setOnError(() => {
logger.setLogError(
~value="Error loading Mastercard script",
~eventName=CLICK_TO_PAY_SCRIPT,
)
let exn = Exn.anyToExnInternal("Failed to load Mastercard script")
exn->reject
})
appendChild(script)
}
}
})
}
// Define props types for each component
type srcMarkProps = {
@as("card-brands") cardBrands?: string,
height?: string,
width?: string,
className?: string,
}
type srcLoaderProps = {
className?: string,
size?: string,
}
type srcLearnMoreProps = {
@as("card-brands") cardBrands: string,
className?: string,
}
// Components in modules with capitalized names (React convention)
module SrcMark = {
@val
external makeOrig: (@as("src-mark") _, srcMarkProps) => React.element = "React.createElement"
let make = React.memo(makeOrig)
}
module SrcLoader = {
@val
external make: (@as("src-loader") _, srcLoaderProps) => React.element = "React.createElement"
}
module SrcLearnMore = {
@val
external make: (@as("src-learn-more") _, srcLearnMoreProps) => React.element =
"React.createElement"
}
type paramUrl = {
key: string,
value: string,
}
let defaultParamUrl = {
key: "",
value: "",
}
let urlToParamUrlItemToObjMapper = url => {
let params = url->String.replace("?", "")->String.split("&")
params
->Array.filter(param => param !== "")
->Array.map(param => {
let paramValues = param->String.split("=")
{
key: paramValues->Array.get(0)->Option.getOr(""),
value: paramValues->Array.get(1)->Option.getOr(""),
}
})
}
let handleProceedToPay = async (
~srcDigitalCardId: string="",
~encryptedCard: JSON.t=JSON.Encode.null,
~isCheckoutWithNewCard: bool=false,
~isUnrecognizedUser: bool=false,
~email: string="",
~phoneNumber: string="",
~countryCode: string="",
~rememberMe: bool=false,
~logger: HyperLogger.loggerMake,
) => {
let closeWindow = (status, payload: JSON.t) => {
handleCloseClickToPayWindow()
{
status,
payload,
}
}
let handleSuccessResponse = response => {
let checkoutActionCode =
response->Utils.getDictFromJson->Utils.getString("checkoutActionCode", "")
switch checkoutActionCode {
| "COMPLETE" => closeWindow(COMPLETE, response)
| "ERROR" => closeWindow(ERROR, response)
| "CANCEL" => closeWindow(CANCEL, response)
| "PAY_V3_CARD" => closeWindow(PAY_V3_CARD, response)
| _ => closeWindow(ERROR, response)
}
}
let handleCheckoutWithCard = async () => {
switch clickToPayWindowRef.contents->Nullable.toOption {
| Some(window) => {
let checkoutResp = await checkoutWithCard(~windowRef=window, ~srcDigitalCardId, ~logger)
switch checkoutResp {
| Ok(response) => response->handleSuccessResponse
| Error(_) => closeWindow(ERROR, JSON.Encode.null)
}
}
| None => {
logger.setLogError(
~value="Click to Pay window reference is null",
~eventName=CLICK_TO_PAY_FLOW,
)
closeWindow(ERROR, JSON.Encode.null)
}
}
}
let handleCheckoutWithNewCard = async () => {
switch clickToPayWindowRef.contents->Nullable.toOption {
| Some(window) => {
let cardBrand = encryptedCard->Utils.getDictFromJson->Utils.getString("cardBrand", "")
let encryptedCard =
encryptedCard
->Utils.getDictFromJson
->Utils.getJsonFromDict("encryptedCard", JSON.Encode.null)
let consumer = {
emailAddress: email,
mobileNumber: {
phoneNumber,
countryCode,
},
}
let complianceSettings = {
privacy: {
acceptedVersion: "LATEST",
latestVersion: "LATEST",
latestVersionUri: "https://www.mastercard.com/global/click-to-pay/country-listing/privacy.html",
},
tnc: {
acceptedVersion: "LATEST",
latestVersion: "LATEST",
latestVersionUri: "https://www.mastercard.com/global/click-to-pay/country-listing/terms.html",
},
cookie: {
acceptedVersion: "LATEST",
latestVersion: "LATEST",
latestVersionUri: "https://www.mastercard.com/global/click-to-pay/en-us/privacy-notice.html",
},
}
let payload = if isUnrecognizedUser {
{
windowRef: window,
cardBrand,
encryptedCard,
rememberMe,
complianceSettings,
consumer,
}
} else {
{
windowRef: window,
cardBrand,
encryptedCard,
rememberMe,
complianceSettings,
}
}
let checkoutResp = await checkoutWithNewCard(payload, ~logger)
switch checkoutResp {
| Ok(response) => response->handleSuccessResponse
| Error(_) => closeWindow(ERROR, JSON.Encode.null)
}
}
| None => {
logger.setLogError(
~value="Click to Pay window reference is null",
~eventName=CLICK_TO_PAY_FLOW,
)
closeWindow(ERROR, JSON.Encode.null)
}
}
}
try {
if clickToPayWindowRef.contents->Nullable.toOption->Option.isNone {
handleOpenClickToPayWindow()
}
if isCheckoutWithNewCard {
await handleCheckoutWithNewCard()
} else {
await handleCheckoutWithCard()
}
} catch {
| err => {
logger.setLogError(
~value=`Error during checkout - ${err->Utils.formatException->JSON.stringify}`,
~eventName=CLICK_TO_PAY_FLOW,
)
closeWindow(ERROR, JSON.Encode.null)
}
}
}
// First add the external binding for signOut
@send
external signOutMastercard: mastercardCheckoutServices => promise<JSON.t> = "signOut"
// Then add the signOut function implementation
let signOut = async () => {
try {
deleteLocalStorage(~key=recognitionTokenCookieName)
switch mcCheckoutService.contents {
| Some(service) => {
let signOutResp = await service->signOutMastercard
Ok(signOutResp)
}
| None => {
Console.error("Mastercard Checkout Service not initialized")
Error(Exn.anyToExnInternal("Mastercard Checkout Service not initialized"))
}
}
} catch {
| error => {
Console.error2("Error during signOut:", error)
Error(error)
}
}
}
| 6,435 | 10,358 |
hyperswitch-web
|
src/Types/GooglePayType.res
|
.res
|
open Utils
@val @scope("Object") external assign: (JSON.t, JSON.t, JSON.t) => JSON.t = "assign"
type transactionInfo = {
countryCode: string,
currencyCode: string,
totalPriceStatus: string,
totalPrice: string,
}
type merchantInfo = {merchantName: string}
type paymentDataRequest = {
mutable allowedPaymentMethods: array<JSON.t>,
mutable transactionInfo: JSON.t,
mutable merchantInfo: JSON.t,
mutable shippingAddressRequired: bool,
mutable emailRequired: bool,
mutable shippingAddressParameters: JSON.t,
mutable callbackIntents: array<JSON.t>,
}
@val @scope("Object") external assign2: (JSON.t, JSON.t) => paymentDataRequest = "assign"
type element = {
mutable innerHTML: string,
appendChild: Dom.element => unit,
removeChild: Dom.element => unit,
children: array<Dom.element>,
}
type document
@val external document: document = "document"
@send external getElementById: (document, string) => element = "getElementById"
type client = {
isReadyToPay: JSON.t => promise<JSON.t>,
createButton: JSON.t => Dom.element,
loadPaymentData: JSON.t => promise<Fetch.Response.t>,
}
@new external google: JSON.t => client = "google.payments.api.PaymentsClient"
let getLabel = (var: PaymentType.googlePayStyleType) => {
switch var {
| Default => "plain"
| Donate => "donate"
| Buy => "buy"
| Pay => "pay"
| Book => "book"
| Order => "order"
| Subscribe => "subscribe"
| Checkout => "checkout"
}
}
type baseRequest = {
apiVersion: int,
apiVersionMinor: int,
}
type parameters = {
gateway: option<string>,
gatewayMerchantId: option<string>,
allowedAuthMethods: option<array<string>>,
allowedCardNetworks: option<array<string>>,
}
type tokenizationSpecification = {
\"type": string,
parameters: parameters,
}
type tokenizationData = {token: string}
type paymentMethodData = {
description: string,
info: JSON.t,
tokenizationData: JSON.t,
\"type": string,
}
type billingContact = {
address1: string,
address2: string,
address3: string,
administrativeArea: string,
countryCode: string,
locality: string,
name: string,
phoneNumber: string,
postalCode: string,
sortingCode: string,
}
type paymentData = {paymentMethodData: paymentMethodData}
let defaultTokenizationData = {
token: "",
}
let defaultPaymentMethodData = {
description: "",
info: Dict.make()->JSON.Encode.object,
tokenizationData: Dict.make()->JSON.Encode.object,
\"type": "",
}
let getTokenizationData = (str, dict) => {
dict
->Dict.get(str)
->Option.flatMap(JSON.Decode.object)
->Option.map(json => {
{
token: getString(json, "token", ""),
}
})
->Option.getOr(defaultTokenizationData)
}
let getPaymentMethodData = (str, dict) => {
dict
->Dict.get(str)
->Option.flatMap(JSON.Decode.object)
->Option.map(json => {
{
description: getString(json, "description", ""),
tokenizationData: getJsonFromDict(json, "tokenizationData", Dict.make()->JSON.Encode.object),
info: getJsonFromDict(json, "info", Dict.make()->JSON.Encode.object),
\"type": getString(json, "type", ""),
}
})
->Option.getOr(defaultPaymentMethodData)
}
let itemToObjMapper = dict => {
{
paymentMethodData: getPaymentMethodData("paymentMethodData", dict),
}
}
let jsonToPaymentRequestDataType: (paymentDataRequest, Dict.t<JSON.t>) => paymentDataRequest = (
paymentRequest,
jsonDict,
) => {
paymentRequest.allowedPaymentMethods =
jsonDict
->getArray("allowed_payment_methods")
->Array.map(json => transformKeys(json, CamelCase))
paymentRequest.transactionInfo =
jsonDict
->getJsonFromDict("transaction_info", JSON.Encode.null)
->transformKeys(CamelCase)
paymentRequest.merchantInfo =
jsonDict
->getJsonFromDict("merchant_info", JSON.Encode.null)
->transformKeys(CamelCase)
paymentRequest
}
let billingContactItemToObjMapper = dict => {
{
address1: dict->getString("address1", ""),
address2: dict->getString("address2", ""),
address3: dict->getString("address3", ""),
administrativeArea: dict->getString("administrativeArea", ""),
countryCode: dict->getString("countryCode", ""),
locality: dict->getString("locality", ""),
name: dict->getString("name", ""),
phoneNumber: dict->getString("phoneNumber", ""),
postalCode: dict->getString("postalCode", ""),
sortingCode: dict->getString("sortingCode", ""),
}
}
let baseRequest = {
"apiVersion": 2,
"apiVersionMinor": 0,
}
let getPaymentDataFromSession = (~sessionObj, ~componentName) => {
let gpayobj = switch sessionObj {
| Some(val) => val
| _ => SessionsType.defaultToken
}
let paymentDataRequest = assign2(
Dict.make()->JSON.Encode.object,
baseRequest->Identity.anyTypeToJson,
)
paymentDataRequest.allowedPaymentMethods = gpayobj.allowed_payment_methods->arrayJsonToCamelCase
paymentDataRequest.transactionInfo = gpayobj.transaction_info->transformKeys(CamelCase)
paymentDataRequest.merchantInfo = gpayobj.merchant_info->transformKeys(CamelCase)
paymentDataRequest.emailRequired = gpayobj.emailRequired
if componentName->getIsExpressCheckoutComponent {
paymentDataRequest.shippingAddressRequired = gpayobj.shippingAddressRequired
paymentDataRequest.shippingAddressParameters =
gpayobj.shippingAddressParameters->transformKeys(CamelCase)
paymentDataRequest.callbackIntents = ["SHIPPING_ADDRESS"->JSON.Encode.string]
}
paymentDataRequest
}
| 1,347 | 10,359 |
hyperswitch-web
|
src/Types/ACHTypes.res
|
.res
|
type data = {
routingNumber: string,
accountNumber: string,
accountHolderName: string,
accountType: string,
iban: string,
sortCode: string,
requiredFieldsBody?: Dict.t<JSON.t>,
}
| 53 | 10,360 |
hyperswitch-web
|
src/Types/PostalCodeType.res
|
.res
|
type postalCodes = {
iso: string,
format: string,
regex: string,
}
let defaultPostalCode = {
iso: "",
format: "",
regex: "",
}
type themeDataModule = {default: array<postalCodes>}
@val
external importPostalCode: string => promise<themeDataModule> = "import"
| 74 | 10,361 |
hyperswitch-web
|
src/Types/CardThemeType.res
|
.res
|
type theme = Default | Brutal | Midnight | Soft | Charcoal | Bubblegum | NONE
type innerLayout = Spaced | Compressed
type showLoader = Auto | Always | Never
type mode =
| Card
| Payment
| CardNumberElement
| CardExpiryElement
| CardCVCElement
| PaymentMethodCollectElement
| GooglePayElement
| PayPalElement
| ApplePayElement
| SamsungPayElement
| KlarnaElement
| PazeElement
| ExpressCheckoutElement
| PaymentMethodsManagement
| NONE
type label = Above | Floating | Never
type themeClass = {
fontFamily: string,
fontSizeBase: string,
colorPrimary: string,
colorBackground: string,
colorText: string,
colorDanger: string,
borderRadius: string,
fontVariantLigatures: string,
fontVariationSettings: string,
spacingUnit: string,
fontWeightLight: string,
fontWeightNormal: string,
fontWeightMedium: string,
fontWeightBold: string,
fontLineHeight: string,
fontSize2Xl: string,
fontSizeXl: string,
fontSizeLg: string,
fontSizeSm: string,
fontSizeXs: string,
fontSize2Xs: string,
fontSize3Xs: string,
colorSuccess: string,
colorWarning: string,
colorPrimaryText: string,
colorBackgroundText: string,
colorSuccessText: string,
colorDangerText: string,
colorWarningText: string,
colorTextSecondary: string,
colorTextPlaceholder: string,
spacingTab: string,
borderColor: string,
spacingAccordionItem: string,
colorIconCardCvc: string,
colorIconCardCvcError: string,
colorIconCardError: string,
spacingGridColumn: string,
spacingGridRow: string,
buttonBackgroundColor: string,
buttonHeight: string,
buttonWidth: string,
buttonBorderRadius: string,
buttonBorderColor: string,
buttonTextColor: string,
buttonTextFontSize: string,
buttonTextFontWeight: string,
buttonBorderWidth: string,
}
type appearance = {
theme: theme,
componentType: string,
variables: themeClass,
rules: JSON.t,
labels: label,
innerLayout: innerLayout,
}
type fonts = {
cssSrc: string,
family: string,
src: string,
weight: string,
}
type configClass = {
appearance: appearance,
locale: string,
ephemeralKey: string,
clientSecret: string,
fonts: array<fonts>,
loader: showLoader,
}
let getPaymentMode = val => {
switch val {
| "card" => Card
| "payment" => Payment
| "cardNumber" => CardNumberElement
| "cardExpiry" => CardExpiryElement
| "cardCvc" => CardCVCElement
| "googlePay" => GooglePayElement
| "payPal" => PayPalElement
| "applePay" => ApplePayElement
| "paymentMethodCollect" => PaymentMethodCollectElement
| "samsungPay" => SamsungPayElement
| "klarna" => KlarnaElement
| "expressCheckout" => ExpressCheckoutElement
| "paze" => PazeElement
| "paymentMethodsManagement" => PaymentMethodsManagement
| _ => NONE
}
}
let getPaymentModeToStrMapper = (val: mode) => (val :> string)
| 769 | 10,362 |
hyperswitch-web
|
src/Types/PaymentType.res
|
.res
|
type showTerms = Auto | Always | Never
type showType = Auto | Never
type layout = Accordion | Tabs
open Utils
open ErrorUtils
type showAddress = {
line1: showType,
line2: showType,
city: showType,
state: showType,
country: showType,
postal_code: showType,
}
type alias = {
paymentMethodName: string,
aliasName: string,
}
type customMethodNames = array<alias>
type address = {
line1: string,
line2: string,
city: string,
state: string,
country: string,
postal_code: string,
}
type addressType =
| JSONString(string)
| JSONObject(showAddress)
type details = {
name: showType,
email: showType,
phone: showType,
address: addressType,
}
type billingDetails = {
name: string,
email: string,
phone: string,
address: address,
}
type billing =
| JSONString(string)
| JSONObject(details)
type defaultValues = {billingDetails: billingDetails}
type fields = {billingDetails: billing}
type terms = {
auBecsDebit: showTerms,
bancontact: showTerms,
card: showTerms,
ideal: showTerms,
sepaDebit: showTerms,
sofort: showTerms,
usBankAccount: showTerms,
}
type buttonHeight = Default | Custom
type heightType = ApplePay(int) | GooglePay(int) | Paypal(int) | Klarna(int) | SamsungPay(int)
type googlePayStyleType = Default | Buy | Donate | Checkout | Subscribe | Book | Pay | Order
type samsungPayStyleType = Buy
type paypalStyleType = Paypal | Checkout | Buynow | Pay | Installment
type applePayStyleType =
| Default
| Buy
| Donate
| Checkout
| Subscribe
| Reload
| Addmoney
| Topup
| Rent
| Order
| Support
| Tip
| Contribute
type styleType =
| ApplePay(applePayStyleType)
| GooglePay(googlePayStyleType)
| Paypal(paypalStyleType)
| SamsungPay(samsungPayStyleType)
type styleTypeArray = (styleType, styleType, styleType, styleType)
type theme = Dark | Light | Outline
type style = {
type_: styleTypeArray,
theme: theme,
height: (heightType, heightType, heightType, heightType, heightType),
buttonRadius: int,
}
type wallets = {
walletReturnUrl: string,
applePay: showType,
googlePay: showType,
payPal: showType,
klarna: showType,
paze: showType,
samsungPay: showType,
style: style,
}
type business = {name: string}
type layoutConfig = {
defaultCollapsed: bool,
radios: bool,
spacedAccordionItems: bool,
maxAccordionItems: int,
\"type": layout,
}
type layoutType =
| StringLayout(layout)
| ObjectLayout(layoutConfig)
type customerCard = {
scheme: option<string>,
last4Digits: string,
expiryMonth: string,
expiryYear: string,
cardToken: string,
cardHolderName: option<string>,
nickname: string,
isClickToPayCard: bool,
}
type bank = {mask: string}
type addressDetails = {
line1: option<string>,
line2: option<string>,
line3: option<string>,
city: option<string>,
state: option<string>,
country: option<string>,
zip: option<string>,
}
type billingAddressPaymentMethod = {address: addressDetails}
type customerMethods = {
paymentToken: string,
customerId: string,
paymentMethod: string,
paymentMethodId: string,
paymentMethodIssuer: option<string>,
card: customerCard,
paymentMethodType: option<string>,
defaultPaymentMethodSet: bool,
requiresCvv: bool,
lastUsedAt: string,
bank: bank,
recurringEnabled: bool,
billing: billingAddressPaymentMethod,
}
type savedCardsLoadState =
LoadingSavedCards | LoadedSavedCards(array<customerMethods>, bool) | NoResult(bool)
type billingAddress = {
isUseBillingAddress: bool,
usePrefilledValues: showType,
}
type sdkHandleConfirmPayment = {
handleConfirm: bool,
buttonText?: string,
confirmParams: ConfirmType.confirmParams,
}
type options = {
defaultValues: defaultValues,
layout: layoutType,
business: business,
customerPaymentMethods: savedCardsLoadState,
savedPaymentMethods: savedCardsLoadState,
paymentMethodOrder: option<array<string>>,
displaySavedPaymentMethodsCheckbox: bool,
displaySavedPaymentMethods: bool,
fields: fields,
readOnly: bool,
terms: terms,
wallets: wallets,
customMethodNames: customMethodNames,
branding: showType,
payButtonStyle: style,
showCardFormByDefault: bool,
billingAddress: billingAddress,
sdkHandleConfirmPayment: sdkHandleConfirmPayment,
paymentMethodsHeaderText?: string,
savedPaymentMethodsHeaderText?: string,
hideExpiredPaymentMethods: bool,
displayDefaultSavedPaymentIcon: bool,
hideCardNicknameField: bool,
displayBillingDetails: bool,
customMessageForCardTerms: string,
showShortSurchargeMessage: bool,
}
type payerDetails = {
email: option<string>,
phone: option<string>,
}
let defaultCardDetails = {
scheme: None,
last4Digits: "",
expiryMonth: "",
expiryYear: "",
cardToken: "",
cardHolderName: None,
nickname: "",
isClickToPayCard: false,
}
let defaultAddressDetails = {
line1: None,
line2: None,
line3: None,
city: None,
state: None,
country: None,
zip: None,
}
let defaultDisplayBillingDetails = {
address: defaultAddressDetails,
}
let defaultCustomerMethods = {
paymentToken: "",
customerId: "",
paymentMethod: "",
paymentMethodId: "",
paymentMethodIssuer: None,
card: defaultCardDetails,
paymentMethodType: None,
defaultPaymentMethodSet: false,
requiresCvv: true,
lastUsedAt: "",
bank: {mask: ""},
recurringEnabled: false,
billing: defaultDisplayBillingDetails,
}
let defaultLayout = {
defaultCollapsed: false,
radios: false,
spacedAccordionItems: false,
maxAccordionItems: 4,
\"type": Tabs,
}
let defaultAddress: address = {
line1: "",
line2: "",
city: "",
state: "",
country: "",
postal_code: "",
}
let defaultBillingDetails: billingDetails = {
name: "",
email: "",
phone: "",
address: defaultAddress,
}
let defaultBusiness = {
name: "",
}
let defaultDefaultValues: defaultValues = {
billingDetails: defaultBillingDetails,
}
let defaultshowAddress: showAddress = {
line1: Auto,
line2: Auto,
city: Auto,
state: Auto,
country: Auto,
postal_code: Auto,
}
let defaultNeverShowAddress: showAddress = {
line1: Never,
line2: Never,
city: Never,
state: Never,
country: Never,
postal_code: Never,
}
let defaultBilling: details = {
name: Auto,
email: Auto,
phone: Auto,
address: JSONObject(defaultshowAddress),
}
let defaultNeverBilling: details = {
name: Never,
email: Never,
phone: Never,
address: JSONObject(defaultNeverShowAddress),
}
let defaultTerms = {
auBecsDebit: Auto,
bancontact: Auto,
card: Auto,
ideal: Auto,
sepaDebit: Auto,
sofort: Auto,
usBankAccount: Auto,
}
let defaultFields = {
billingDetails: JSONObject(defaultBilling),
}
let defaultStyle = {
type_: (ApplePay(Default), GooglePay(Default), Paypal(Paypal), SamsungPay(Buy)),
theme: Light,
height: (ApplePay(48), GooglePay(48), Paypal(48), Klarna(48), SamsungPay(48)),
buttonRadius: 2,
}
let defaultWallets = {
walletReturnUrl: "",
applePay: Auto,
googlePay: Auto,
payPal: Auto,
klarna: Auto,
paze: Auto,
samsungPay: Auto,
style: defaultStyle,
}
let defaultBillingAddress = {
isUseBillingAddress: false,
usePrefilledValues: Auto,
}
let defaultSdkHandleConfirmPayment = {
handleConfirm: false,
confirmParams: ConfirmType.defaultConfirm,
}
let defaultOptions = {
defaultValues: defaultDefaultValues,
business: defaultBusiness,
customerPaymentMethods: LoadingSavedCards,
savedPaymentMethods: LoadingSavedCards,
layout: ObjectLayout(defaultLayout),
paymentMethodOrder: None,
fields: defaultFields,
displaySavedPaymentMethodsCheckbox: true,
displaySavedPaymentMethods: true,
readOnly: false,
terms: defaultTerms,
branding: Auto,
wallets: defaultWallets,
payButtonStyle: defaultStyle,
customMethodNames: [],
showCardFormByDefault: true,
billingAddress: defaultBillingAddress,
sdkHandleConfirmPayment: defaultSdkHandleConfirmPayment,
hideExpiredPaymentMethods: false,
displayDefaultSavedPaymentIcon: true,
hideCardNicknameField: false,
displayBillingDetails: false,
customMessageForCardTerms: "",
showShortSurchargeMessage: false,
}
let getLayout = (str, logger) => {
switch str {
| "tabs" => Tabs
| "accordion" => Accordion
| str => {
str->unknownPropValueWarning(["tabs", "accordion"], "options.layout", ~logger)
Tabs
}
}
}
let getAddress = (dict, str, logger) => {
dict
->Dict.get(str)
->Option.flatMap(JSON.Decode.object)
->Option.map(json => {
let countryNames = []
Country.country->Array.map(item => countryNames->Array.push(item.countryName))->ignore
unknownKeysWarning(
["line1", "line2", "city", "state", "country", "postal_code"],
json,
"options.defaultValues.billingDetails.address",
~logger,
)
let country = getWarningString(json, "country", "", ~logger)
if country != "" {
unknownPropValueWarning(
country,
countryNames,
"options.defaultValues.billingDetails.address.country",
~logger,
)
}
{
line1: getWarningString(json, "line1", "", ~logger),
line2: getWarningString(json, "line2", "", ~logger),
city: getWarningString(json, "city", "", ~logger),
state: getWarningString(json, "state", "", ~logger),
country,
postal_code: getWarningString(json, "postal_code", "", ~logger),
}
})
->Option.getOr(defaultAddress)
}
let getBillingDetails = (dict, str, logger) => {
dict
->Dict.get(str)
->Option.flatMap(JSON.Decode.object)
->Option.map(json => {
unknownKeysWarning(
["name", "email", "phone", "address"],
json,
"options.defaultValues.billingDetails",
~logger,
)
{
name: getWarningString(json, "name", "", ~logger),
email: getWarningString(json, "email", "", ~logger),
phone: getWarningString(json, "phone", "", ~logger),
address: getAddress(json, "address", logger),
}
})
->Option.getOr(defaultBillingDetails)
}
let getDefaultValues = (dict, str, logger) => {
dict
->Dict.get(str)
->Option.flatMap(JSON.Decode.object)
->Option.map(json => {
unknownKeysWarning(["billingDetails"], json, "options.defaultValues", ~logger)
let defaultValues: defaultValues = {
billingDetails: getBillingDetails(json, "billingDetails", logger),
}
defaultValues
})
->Option.getOr(defaultDefaultValues)
}
let getBusiness = (dict, str, logger) => {
dict
->Dict.get(str)
->Option.flatMap(JSON.Decode.object)
->Option.map(json => {
unknownKeysWarning(["name"], json, "options.business", ~logger)
{
name: getWarningString(json, "name", "", ~logger),
}
})
->Option.getOr(defaultBusiness)
}
let getShowType = (str, key, logger) => {
switch str {
| "auto" => Auto
| "never" => Never
| str => {
str->unknownPropValueWarning(["auto", "never"], key, ~logger)
Auto
}
}
}
let getApplePayType = str => {
switch str {
| "buy"
| "buynow" =>
ApplePay(Buy)
| "donate" => ApplePay(Donate)
| "check-out"
| "checkout" =>
ApplePay(Checkout)
| "subscribe" => ApplePay(Subscribe)
| "reload" => ApplePay(Reload)
| "add-money"
| "addmoney" =>
ApplePay(Addmoney)
| "top-up"
| "topup" =>
ApplePay(Topup)
| "rent" => ApplePay(Rent)
| "order" => ApplePay(Order)
| "support" => ApplePay(Support)
| "tip" => ApplePay(Tip)
| "contribute" => ApplePay(Contribute)
| "default"
| _ =>
ApplePay(Default)
}
}
let getGooglePayType = str => {
switch str {
| "buy"
| "buynow" =>
GooglePay(Buy)
| "book" => GooglePay(Book)
| "pay" => GooglePay(Pay)
| "donate" => GooglePay(Donate)
| "check-out"
| "checkout" =>
GooglePay(Checkout)
| "order" => GooglePay(Order)
| "subscribe" => GooglePay(Subscribe)
| "default"
| "plain"
| _ =>
GooglePay(Default)
}
}
let getSamsungPayType = str => {
switch str {
| _ => SamsungPay(Buy)
}
}
let getPayPalType = str => {
switch str {
| "check-out"
| "checkout" =>
Paypal(Checkout)
| "installment" => Paypal(Installment)
| "buy"
| "buynow" =>
Paypal(Buynow)
| "pay" => Paypal(Pay)
| "paypal"
| _ =>
Paypal(Paypal)
}
}
let getTypeArray = (str, logger) => {
let goodVals = [
"checkout",
"pay",
"buy",
"installment",
"pay",
"default",
"book",
"donate",
"order",
"addmoney",
"topup",
"rent",
"subscribe",
"reload",
"support",
"tip",
"contribute",
]
if !Array.includes(goodVals, str) {
str->unknownPropValueWarning(goodVals, "options.wallets.style.type", ~logger)
}
(str->getApplePayType, str->getGooglePayType, str->getPayPalType, str->getSamsungPayType)
}
let getShowDetails = (~billingDetails, ~logger) => {
switch billingDetails {
| JSONObject(obj) => obj
| JSONString(str) =>
str->getShowType("fields.billingDetails", logger) == Never
? defaultNeverBilling
: defaultBilling
}
}
let getShowAddressDetails = (~billingDetails, ~logger) => {
switch billingDetails {
| JSONObject(obj) =>
switch obj.address {
| JSONString(str) =>
str->getShowType("fields.billingDetails.address", logger) == Never
? defaultNeverShowAddress
: defaultshowAddress
| JSONObject(obj) => obj
}
| JSONString(str) =>
str->getShowType("fields.billingDetails", logger) == Never
? defaultNeverShowAddress
: defaultshowAddress
}
}
let getShowTerms: (string, string, 'a) => showTerms = (str, key, logger) => {
switch str {
| "auto" => Auto
| "always" => Always
| "never" => Never
| str => {
str->unknownPropValueWarning(["auto", "always", "never"], key, ~logger)
Auto
}
}
}
let getShowAddress = (dict, str, logger) => {
dict
->Dict.get(str)
->Option.flatMap(JSON.Decode.object)
->Option.map(json => {
let x: showAddress = {
line1: getWarningString(json, "line1", "auto", ~logger)->getShowType(
"options.fields.address.line1",
logger,
),
line2: getWarningString(json, "line2", "auto", ~logger)->getShowType(
"options.fields.address.line2",
logger,
),
city: getWarningString(json, "city", "auto", ~logger)->getShowType(
"options.fields.address.city",
logger,
),
state: getWarningString(json, "state", "auto", ~logger)->getShowType(
"options.fields.address.state",
logger,
),
country: getWarningString(json, "country", "auto", ~logger)->getShowType(
"options.fields.address.country",
logger,
),
postal_code: getWarningString(json, "postal_code", "auto", ~logger)->getShowType(
"options.fields.name.postal_code",
logger,
),
}
x
})
->Option.getOr(defaultshowAddress)
}
let getDeatils = (val, logger) => {
switch val->JSON.Classify.classify {
| String(str) => JSONString(str)
| Object(json) =>
JSONObject({
name: getWarningString(json, "name", "auto", ~logger)->getShowType(
"options.fields.name",
logger,
),
email: getWarningString(json, "email", "auto", ~logger)->getShowType(
"options.fields.email",
logger,
),
phone: getWarningString(json, "phone", "auto", ~logger)->getShowType(
"options.fields.phone",
logger,
),
address: JSONObject(getShowAddress(json, "address", logger)),
})
| _ => JSONString("")
}
}
let getBilling = (dict, str, logger) => {
dict
->Dict.get(str)
->Option.map(json => json->getDeatils(logger))
->Option.getOr(defaultFields.billingDetails)
}
let getFields: (Dict.t<JSON.t>, string, 'a) => fields = (dict, str, logger) => {
dict
->Dict.get(str)
->Option.flatMap(JSON.Decode.object)
->Option.map(json => {
let defaultFields: fields = {
billingDetails: getBilling(json, "billingDetails", logger),
}
defaultFields
})
->Option.getOr(defaultFields)
}
let getLayoutValues = (val, logger) => {
switch val->JSON.Classify.classify {
| String(str) => StringLayout(str->getLayout(logger))
| Object(json) =>
ObjectLayout({
let layoutType = getWarningString(json, "type", "tabs", ~logger)
unknownKeysWarning(
["defaultCollapsed", "radios", "spacedAccordionItems", "type", "maxAccordionItems"],
json,
"options.layout",
~logger,
)
{
defaultCollapsed: getBoolWithWarning(json, "defaultCollapsed", false, ~logger),
radios: getBoolWithWarning(json, "radios", false, ~logger),
spacedAccordionItems: getBoolWithWarning(json, "spacedAccordionItems", false, ~logger),
maxAccordionItems: getNumberWithWarning(json, "maxAccordionItems", 4, ~logger),
\"type": layoutType->getLayout(logger),
}
})
| _ => StringLayout(Tabs)
}
}
let getTerms = (dict, str, logger) => {
dict
->Dict.get(str)
->Option.flatMap(JSON.Decode.object)
->Option.map(json => {
unknownKeysWarning(
["auBecsDebit", "bancontact", "card", "ideal", "sepaDebit", "sofort", "usBankAccount"],
json,
"options.terms",
~logger,
)
{
auBecsDebit: getWarningString(json, "auBecsDebit", "auto", ~logger)->getShowTerms(
"options.terms.auBecsDebit",
logger,
),
bancontact: getWarningString(json, "bancontact", "auto", ~logger)->getShowTerms(
"options.terms.bancontact",
logger,
),
card: getWarningString(json, "card", "auto", ~logger)->getShowTerms(
"options.terms.card",
logger,
),
ideal: getWarningString(json, "ideal", "auto", ~logger)->getShowTerms(
"options.terms.ideal",
logger,
),
sepaDebit: getWarningString(json, "sepaDebit", "auto", ~logger)->getShowTerms(
"options.terms.sepaDebit",
logger,
),
sofort: getWarningString(json, "sofort", "auto", ~logger)->getShowTerms(
"options.terms.sofort",
logger,
),
usBankAccount: getWarningString(json, "usBankAccount", "auto", ~logger)->getShowTerms(
"options.terms.usBankAccount",
logger,
),
}
})
->Option.getOr(defaultTerms)
}
let getApplePayHeight: (int, 'a) => heightType = (val, logger) => {
if val >= 45 {
ApplePay(val)
} else {
valueOutRangeWarning(
val,
"options.style.height",
"[h>=45] - ApplePay. Value set to min",
~logger,
)
ApplePay(48)
}
}
let getGooglePayHeight: (int, 'a) => heightType = (val, logger) => {
if val >= 45 {
GooglePay(val)
} else {
valueOutRangeWarning(
val,
"options.style.height",
"[h>=45] - GooglePay. Value set to min",
~logger,
)
GooglePay(48)
}
}
let getSamsungPayHeight: (int, 'a) => heightType = (val, logger) => {
if val >= 45 {
SamsungPay(val)
} else {
valueOutRangeWarning(
val,
"options.style.height",
"[h>=45] - SamsungPay. Value set to min",
~logger,
)
SamsungPay(48)
}
}
let getPaypalHeight: (int, 'a) => heightType = (val, logger) => {
if val < 25 {
valueOutRangeWarning(val, "options.style.height", "[25-55] - Paypal. Value set to min", ~logger)
Paypal(25)
} else if val > 55 {
valueOutRangeWarning(val, "options.style.height", "[25-55] - Paypal. Value set to max", ~logger)
Paypal(55)
} else {
Paypal(val)
}
}
let getKlarnaHeight: (int, 'a) => heightType = (val, logger) => {
if val < 40 {
valueOutRangeWarning(val, "options.style.height", "[40-60] - Klarna. Value set to min", ~logger)
Klarna(40)
} else if val > 60 {
valueOutRangeWarning(val, "options.style.height", "[40-60] - Paypal. Value set to max", ~logger)
Klarna(60)
} else {
Klarna(val)
}
}
let getTheme = (str, logger) => {
switch str {
| "outline" => Outline
| "light" => Light
| "dark" => Dark
| _ =>
str->unknownPropValueWarning(["outline", "light", "dark"], "options.styles.theme", ~logger)
Dark
}
}
let getHeightArray = (val, logger) => {
(
val->getApplePayHeight(logger),
val->getGooglePayHeight(logger),
val->getPaypalHeight(logger),
val->getKlarnaHeight(logger),
val->getSamsungPayHeight(logger),
)
}
let getStyle = (dict, str, logger) => {
dict
->Dict.get(str)
->Option.flatMap(JSON.Decode.object)
->Option.map(json => {
unknownKeysWarning(["type", "theme", "height"], json, "options.wallets.style", ~logger)
let style = {
type_: getWarningString(json, "type", "", ~logger)->getTypeArray(logger),
theme: getWarningString(json, "theme", "", ~logger)->getTheme(logger),
height: getNumberWithWarning(json, "height", 48, ~logger)->getHeightArray(logger),
buttonRadius: getNumberWithWarning(json, "buttonRadius", 2, ~logger),
}
style
})
->Option.getOr(defaultStyle)
}
let getWallets = (dict, str, logger) => {
dict
->Dict.get(str)
->Option.flatMap(JSON.Decode.object)
->Option.map(json => {
unknownKeysWarning(
["applePay", "googlePay", "style", "walletReturnUrl", "payPal", "klarna", "samsungPay"],
json,
"options.wallets",
~logger,
)
{
walletReturnUrl: getRequiredString(json, "walletReturnUrl", "", ~logger),
applePay: getWarningString(json, "applePay", "auto", ~logger)->getShowType(
"options.wallets.applePay",
logger,
),
googlePay: getWarningString(json, "googlePay", "auto", ~logger)->getShowType(
"options.wallets.googlePay",
logger,
),
payPal: getWarningString(json, "payPal", "auto", ~logger)->getShowType(
"options.wallets.payPal",
logger,
),
klarna: getWarningString(json, "klarna", "auto", ~logger)->getShowType(
"options.wallets.klarna",
logger,
),
paze: getWarningString(json, "paze", "auto", ~logger)->getShowType(
"options.wallets.paze",
logger,
),
samsungPay: getWarningString(json, "samsungPay", "auto", ~logger)->getShowType(
"options.wallets.samsungPay",
logger,
),
style: getStyle(json, "style", logger),
}
})
->Option.getOr(defaultWallets)
}
let getLayout = (dict, str, logger) => {
dict
->Dict.get(str)
->Option.map(json => {
json->getLayoutValues(logger)
})
->Option.getOr(ObjectLayout(defaultLayout))
}
let getCardDetails = (dict, str) => {
dict
->Dict.get(str)
->Option.flatMap(JSON.Decode.object)
->Option.map(json => {
{
scheme: Some(getString(json, "scheme", "")),
last4Digits: getString(json, "last4_digits", ""),
expiryMonth: getString(json, "expiry_month", ""),
expiryYear: getString(json, "expiry_year", ""),
cardToken: getString(json, "card_token", ""),
cardHolderName: getOptionString(json, "card_holder_name"),
nickname: getString(json, "nick_name", ""),
isClickToPayCard: false,
}
})
->Option.getOr(defaultCardDetails)
}
let getAddressDetails = (dict, str) => {
dict
->Dict.get(str)
->Option.flatMap(JSON.Decode.object)
->Option.map(json => {
line1: Some(getString(json, "line1", "")),
line2: Some(getString(json, "line2", "")),
line3: Some(getString(json, "line3", "")),
city: Some(getString(json, "city", "")),
state: Some(getString(json, "state", "")),
country: Some(getString(json, "country", "")),
zip: Some(getString(json, "zip", "")),
})
->Option.getOr(defaultAddressDetails)
}
let getBillingAddressPaymentMethod = (dict, str) =>
dict
->Dict.get(str)
->Option.flatMap(JSON.Decode.object)
->Option.map(json => {address: getAddressDetails(json, "address")})
->Option.getOr(defaultDisplayBillingDetails)
let getPaymentMethodType = dict => {
dict->Dict.get("payment_method_type")->Option.flatMap(JSON.Decode.string)
}
let getBank = dict => {
{
mask: dict
->getDictFromDict("bank")
->getString("mask", ""),
}
}
let itemToCustomerObjMapper = customerDict => {
let customerArr = customerDict->getArray("customer_payment_methods")
let isGuestCustomer = customerDict->getBool("is_guest_customer", false)
let customerPaymentMethods =
customerArr
->Belt.Array.keepMap(JSON.Decode.object)
->Array.map(dict => {
{
paymentToken: getString(dict, "payment_token", ""),
customerId: getString(dict, "customer_id", ""),
paymentMethod: getString(dict, "payment_method", ""),
paymentMethodId: getString(dict, "payment_method_id", ""),
paymentMethodIssuer: getOptionString(dict, "payment_method_issuer"),
card: getCardDetails(dict, "card"),
paymentMethodType: getPaymentMethodType(dict),
defaultPaymentMethodSet: getBool(dict, "default_payment_method_set", false),
requiresCvv: getBool(dict, "requires_cvv", true),
lastUsedAt: getString(dict, "last_used_at", ""),
bank: dict->getBank,
recurringEnabled: getBool(dict, "recurring_enabled", false),
billing: getBillingAddressPaymentMethod(dict, "billing"),
}
})
(customerPaymentMethods, isGuestCustomer)
}
let createCustomerObjArr = (dict, key) => {
let customerDict =
dict
->Dict.get(key)
->Option.flatMap(JSON.Decode.object)
->Option.getOr(Dict.make())
let (customerPaymentMethods, isGuestCustomer) = customerDict->itemToCustomerObjMapper
LoadedSavedCards(customerPaymentMethods, isGuestCustomer)
}
let getCustomerMethods = (dict, str) => {
let customerArr = dict->Dict.get(str)->Option.flatMap(JSON.Decode.array)->Option.getOr([])
if customerArr->Array.length !== 0 {
let customerPaymentMethods =
customerArr
->Belt.Array.keepMap(JSON.Decode.object)
->Array.map(json => {
{
paymentToken: getString(json, "payment_token", ""),
customerId: getString(json, "customer_id", ""),
paymentMethod: getString(json, "payment_method", ""),
paymentMethodId: getString(json, "payment_method_id", ""),
paymentMethodIssuer: Some(getString(json, "payment_method_issuer", "")),
card: getCardDetails(json, "card"),
paymentMethodType: getPaymentMethodType(dict),
defaultPaymentMethodSet: getBool(dict, "default_payment_method_set", false),
requiresCvv: getBool(dict, "requires_cvv", true),
lastUsedAt: getString(dict, "last_used_at", ""),
bank: dict->getBank,
recurringEnabled: getBool(dict, "recurring_enabled", false),
billing: getBillingAddressPaymentMethod(json, "billing"),
}
})
LoadedSavedCards(customerPaymentMethods, false)
} else {
LoadingSavedCards
}
}
let getCustomMethodNames = (dict, str) => {
dict
->Dict.get(str)
->Option.flatMap(JSON.Decode.array)
->Option.getOr([])
->Belt.Array.keepMap(JSON.Decode.object)
->Array.map(json => {
paymentMethodName: getString(json, "paymentMethodName", ""),
aliasName: getString(json, "aliasName", ""),
})
}
let getBillingAddress = (dict, str, logger) => {
dict
->Dict.get(str)
->Option.flatMap(JSON.Decode.object)
->Option.map(json => {
unknownKeysWarning(
["isUseBillingAddress", "usePrefilledValues"],
json,
"options.billingAddress",
~logger,
)
{
isUseBillingAddress: getBoolWithWarning(json, "isUseBillingAddress", false, ~logger),
usePrefilledValues: getWarningString(
json,
"usePrefilledValues",
"auto",
~logger,
)->getShowType("options.billingAddress.usePrefilledValues", logger),
}
})
->Option.getOr(defaultBillingAddress)
}
let getConfirmParams = dict => {
open ConfirmType
{
return_url: dict->getString("return_url", ""),
publishableKey: dict->getString("publishableKey", ""),
redirect: dict->getString("redirect", "if_required"),
}
}
let getSdkHandleConfirmPaymentProps = dict => {
handleConfirm: dict->getBool("handleConfirm", false),
buttonText: ?dict->getOptionString("buttonText"),
confirmParams: dict->getDictFromDict("confirmParams")->getConfirmParams,
}
let itemToObjMapper = (dict, logger) => {
unknownKeysWarning(
[
"defaultValues",
"business",
"layout",
"paymentMethodOrder",
"customerPaymentMethods",
"fields",
"readOnly",
"terms",
"wallets",
"showCardFormByDefault",
"displaySavedPaymentMethodsCheckbox",
"displaySavedPaymentMethods",
"sdkHandleOneClickConfirmPayment",
"showCardFormByDefault",
"sdkHandleConfirmPayment",
"paymentMethodsHeaderText",
"savedPaymentMethodsHeaderText",
"hideExpiredPaymentMethods",
"branding",
"displayDefaultSavedPaymentIcon",
"hideCardNicknameField",
"displayBillingDetails",
"customMessageForCardTerms",
"showShortSurchargeMessage",
],
dict,
"options",
~logger,
)
{
defaultValues: getDefaultValues(dict, "defaultValues", logger),
business: getBusiness(dict, "business", logger),
layout: getLayout(dict, "layout", logger),
customerPaymentMethods: getCustomerMethods(dict, "customerPaymentMethods"),
savedPaymentMethods: getCustomerMethods(dict, "customerPaymentMethods"),
paymentMethodOrder: getOptionalStrArray(dict, "paymentMethodOrder"),
fields: getFields(dict, "fields", logger),
branding: getWarningString(dict, "branding", "auto", ~logger)->getShowType(
"options.branding",
logger,
),
displaySavedPaymentMethodsCheckbox: getBoolWithWarning(
dict,
"displaySavedPaymentMethodsCheckbox",
true,
~logger,
),
displaySavedPaymentMethods: getBoolWithWarning(
dict,
"displaySavedPaymentMethods",
true,
~logger,
),
readOnly: getBoolWithWarning(dict, "readOnly", false, ~logger),
terms: getTerms(dict, "terms", logger),
wallets: getWallets(dict, "wallets", logger),
customMethodNames: getCustomMethodNames(dict, "customMethodNames"),
payButtonStyle: getStyle(dict, "payButtonStyle", logger),
showCardFormByDefault: getBool(dict, "showCardFormByDefault", true),
billingAddress: getBillingAddress(dict, "billingAddress", logger),
sdkHandleConfirmPayment: dict
->getDictFromDict("sdkHandleConfirmPayment")
->getSdkHandleConfirmPaymentProps,
paymentMethodsHeaderText: ?getOptionString(dict, "paymentMethodsHeaderText"),
savedPaymentMethodsHeaderText: ?getOptionString(dict, "savedPaymentMethodsHeaderText"),
hideExpiredPaymentMethods: getBool(dict, "hideExpiredPaymentMethods", false),
displayDefaultSavedPaymentIcon: getBool(dict, "displayDefaultSavedPaymentIcon", true),
hideCardNicknameField: getBool(dict, "hideCardNicknameField", false),
displayBillingDetails: getBool(dict, "displayBillingDetails", false),
customMessageForCardTerms: getString(dict, "customMessageForCardTerms", ""),
showShortSurchargeMessage: getBool(dict, "showShortSurchargeMessage", false),
}
}
type loadType = Loading | Loaded(JSON.t) | SemiLoaded | LoadError(JSON.t)
let getIsStoredPaymentMethodHasName = (savedMethod: customerMethods) => {
savedMethod.card.cardHolderName->Option.getOr("")->String.length > 0
}
let itemToPayerDetailsObjectMapper = dict => {
email: dict->Dict.get("email_address")->Option.flatMap(JSON.Decode.string),
phone: dict
->Dict.get("phone")
->Option.flatMap(JSON.Decode.object)
->Option.flatMap(Dict.get(_, "phone_number"))
->Option.flatMap(JSON.Decode.object)
->Option.flatMap(Dict.get(_, "national_number"))
->Option.flatMap(JSON.Decode.string),
}
let convertClickToPayCardToCustomerMethod = (
clickToPayCard: ClickToPayHelpers.clickToPayCard,
): customerMethods => {
paymentToken: clickToPayCard.srcDigitalCardId,
customerId: "", // Empty as Click to Pay doesn't provide this
paymentMethod: "card",
paymentMethodId: clickToPayCard.srcDigitalCardId,
paymentMethodIssuer: None,
card: {
scheme: Some(
switch clickToPayCard.paymentCardDescriptor->String.toLowerCase {
| "amex" => "AmericanExpress"
| "mastercard" => "Mastercard"
| "visa" => "Visa"
| "discover" => "Discover"
| other =>
other
->String.charAt(0)
->String.toUpperCase
->String.concat(other->String.sliceToEnd(~start=1)->String.toLowerCase)
},
),
last4Digits: clickToPayCard.panLastFour,
expiryMonth: clickToPayCard.panExpirationMonth,
expiryYear: clickToPayCard.panExpirationYear,
cardToken: clickToPayCard.srcDigitalCardId,
cardHolderName: None,
nickname: clickToPayCard.digitalCardData.descriptorName,
isClickToPayCard: true,
},
paymentMethodType: Some("click_to_pay"),
defaultPaymentMethodSet: false, // Default to false as Click to Pay doesn't provide this
requiresCvv: false, // Click to Pay handles CVV internally
lastUsedAt: Js.Date.make()->Js.Date.toISOString, // Current timestamp as Click to Pay doesn't provide this
bank: {
mask: "", // Just use the mask field that exists in the type
},
recurringEnabled: true, // Since Click to Pay cards can be used for recurring payments
billing: defaultDisplayBillingDetails,
}
| 8,650 | 10,363 |
hyperswitch-web
|
src/Types/ThemeImporter.res
|
.res
|
type themeDataModule = {
default: CardThemeType.themeClass,
defaultRules: CardThemeType.themeClass => JSON.t,
}
@val
external importTheme: string => promise<themeDataModule> = "import"
| 48 | 10,364 |
hyperswitch-web
|
src/Types/ConfirmType.res
|
.res
|
type confirmParams = {
return_url: string,
publishableKey: string,
redirect?: string,
}
type confirm = {
doSubmit: bool,
clientSecret: string,
confirmParams: confirmParams,
confirmTimestamp: float,
readyTimestamp: float,
}
open Utils
let defaultConfirm = {
return_url: "",
publishableKey: "",
redirect: "if_required",
}
let getConfirmParams = (dict, str) => {
dict
->Dict.get(str)
->Option.flatMap(JSON.Decode.object)
->Option.map(json => {
{
return_url: getString(json, "return_url", ""),
publishableKey: getString(json, "publishableKey", ""),
redirect: getString(json, "redirect", "if_required"),
}
})
->Option.getOr(defaultConfirm)
}
let itemToObjMapper = dict => {
{
doSubmit: getBool(dict, "doSubmit", false),
clientSecret: getString(dict, "clientSecret", ""),
confirmParams: getConfirmParams(dict, "confirmParams"),
confirmTimestamp: getFloat(dict, "confirmTimestamp", 0.0),
readyTimestamp: getFloat(dict, "readyTimestamp", 0.0),
}
}
| 264 | 10,365 |
hyperswitch-web
|
src/libraries/DatePicker.res
|
.res
|
// * For reference - https://reactdatepicker.com/
type customHeaderProps = {
date: Date.t,
selectingDate: Date.t,
monthDate: Date.t,
increaseMonth: unit => unit,
decreaseMonth: unit => unit,
changeMonth: int => unit,
increaseYear: unit => unit,
decreaseYear: unit => unit,
changeYear: unit => unit,
prevMonthButtonDisabled: bool,
nextMonthButtonDisabled: bool,
prevYearButtonDisabled: bool,
nextYearButtonDisabled: bool,
}
@module("react-datepicker") @react.component
external make: (
~selected: Nullable.t<Date.t>,
~onChange: Nullable.t<Date.t> => unit,
~showIcon: bool=?,
~icon: React.element=?,
~dateFormat: string=?,
~customInput: React.element=?,
~popperPlacement: string=?,
~renderCustomHeader: customHeaderProps => React.element=?,
~showWeekNumbers: bool=?,
~placeholderText: string=?,
~className: string=?,
~wrapperClassName: string=?,
~closeOnScroll: bool=?,
~shouldCloseOnSelect: bool=?,
) => React.element = "default"
| 267 | 10,366 |
hyperswitch-web
|
src/libraries/recoil.js
|
.js
|
import {
RecoilRoot,
atom as recoilAtom,
selector,
useRecoilState,
useRecoilValue,
} from "recoil";
export function atom(key, defaultVal) {
return recoilAtom({ key, default: defaultVal });
}
| 56 | 10,367 |
hyperswitch-web
|
src/libraries/Recoil.res
|
.res
|
module RecoilRoot = {
@module("recoil") @react.component
external make: (~children: React.element) => React.element = "RecoilRoot"
}
type recoilAtom<'v> = RecoilAtom('v)
type recoilSelector<'v> = RecoilSelector('v)
@module("./recoil")
external atom: (string, 'v) => recoilAtom<'v> = "atom"
@module("recoil")
external useRecoilState: recoilAtom<'valueT> => ('valueT, ('valueT => 'valueT) => unit) =
"useRecoilState"
@module("recoil")
external useSetRecoilState: recoilAtom<'valueT> => ('valueT => 'valueT) => unit =
"useSetRecoilState"
@module("recoil")
external useRecoilValueFromAtom: recoilAtom<'valueT> => 'valueT = "useRecoilValue"
let useLoggedRecoilState = (atomName, type_, logger: HyperLogger.loggerMake) => {
let (state, setState) = useRecoilState(atomName)
let newSetState = value => {
LoggerUtils.logInputChangeInfo(type_, logger)
setState(value)
}
(state, newSetState)
}
let useLoggedSetRecoilState = (atomName, type_, logger: HyperLogger.loggerMake) => {
let setState = useSetRecoilState(atomName)
let newSetState = value => {
LoggerUtils.logInputChangeInfo(type_, logger)
setState(value)
}
newSetState
}
| 337 | 10,368 |
hyperswitch-web
|
src/libraries/Promise.resi
|
.resi
|
type t<'a> = RescriptCore.Promise.t<'a>
type exn += JsError(RescriptCore.Exn.t)
@new
external make: ((@uncurry 'a => unit, 'e => unit) => unit) => t<'a> = "Promise"
@val @scope("Promise")
external resolve: 'a => t<'a> = "resolve"
@send external then: (t<'a>, @uncurry 'a => t<'b>) => t<'b> = "then"
@send
external thenResolve: (t<'a>, @uncurry 'a => 'b) => t<'b> = "then"
@send external finally: (t<'a>, unit => unit) => t<'a> = "finally"
@scope("Promise") @val
external reject: exn => t<_> = "reject"
@scope("Promise") @val
external all: array<t<'a>> => t<array<'a>> = "all"
@scope("Promise") @val
external all2: ((t<'a>, t<'b>)) => t<('a, 'b)> = "all"
@scope("Promise") @val
external all3: ((t<'a>, t<'b>, t<'c>)) => t<('a, 'b, 'c)> = "all"
@scope("Promise") @val
external all4: ((t<'a>, t<'b>, t<'c>, t<'d>)) => t<('a, 'b, 'c, 'd)> = "all"
@scope("Promise") @val
external all5: ((t<'a>, t<'b>, t<'c>, t<'d>, t<'e>)) => t<('a, 'b, 'c, 'd, 'e)> = "all"
@scope("Promise") @val
external all6: ((t<'a>, t<'b>, t<'c>, t<'d>, t<'e>, t<'f>)) => t<('a, 'b, 'c, 'd, 'e, 'f)> = "all"
@send
external _catch: (t<'a>, @uncurry exn => t<'a>) => t<'a> = "catch"
let catch: (t<'a>, exn => t<'a>) => t<'a>
@scope("Promise") @val
external race: array<t<'a>> => t<'a> = "race"
| 532 | 10,369 |
hyperswitch-web
|
src/libraries/Promise.res
|
.res
|
type t<+'a> = promise<'a>
exception JsError(Exn.t)
@new
external make: ((@uncurry 'a => unit, 'e => unit) => unit) => t<'a> = "Promise"
@val @scope("Promise")
external resolve: 'a => t<'a> = "resolve"
@send external then: (t<'a>, @uncurry 'a => t<'b>) => t<'b> = "then"
@send
external thenResolve: (t<'a>, @uncurry 'a => 'b) => t<'b> = "then"
@send external finally: (t<'a>, unit => unit) => t<'a> = "finally"
@scope("Promise") @val
external reject: exn => t<_> = "reject"
@scope("Promise") @val
external all: array<t<'a>> => t<array<'a>> = "all"
@scope("Promise") @val
external all2: ((t<'a>, t<'b>)) => t<('a, 'b)> = "all"
@scope("Promise") @val
external all3: ((t<'a>, t<'b>, t<'c>)) => t<('a, 'b, 'c)> = "all"
@scope("Promise") @val
external all4: ((t<'a>, t<'b>, t<'c>, t<'d>)) => t<('a, 'b, 'c, 'd)> = "all"
@scope("Promise") @val
external all5: ((t<'a>, t<'b>, t<'c>, t<'d>, t<'e>)) => t<('a, 'b, 'c, 'd, 'e)> = "all"
@scope("Promise") @val
external all6: ((t<'a>, t<'b>, t<'c>, t<'d>, t<'e>, t<'f>)) => t<('a, 'b, 'c, 'd, 'e, 'f)> = "all"
@send
external _catch: (t<'a>, @uncurry exn => t<'a>) => t<'a> = "catch"
let catch = (promise, callback) => {
_catch(promise, err => {
let v = if Exn.isCamlExceptionOrOpenVariant(err) {
err
} else {
JsError(Identity.unsafeToJsExn(err))
}
callback(v)
})
}
@scope("Promise") @val
external race: array<t<'a>> => t<'a> = "race"
| 568 | 10,370 |
hyperswitch-web
|
src/libraries/Plaid.res
|
.res
|
// * For Documentation - https://plaid.com/docs/link/web/
type createArgs = {
token: string,
onSuccess: (string, JSON.t) => unit,
onLoad?: unit => unit,
onExit?: JSON.t => unit,
onEvent?: JSON.t => unit,
}
type createReturn = {
@as("open") open_: unit => unit,
exit: unit => unit,
destroy: unit => unit,
submit: unit => unit,
}
@val @scope(("window", "Plaid"))
external create: createArgs => createReturn = "create"
@val @scope(("window", "Plaid"))
external version: string = "version"
| 143 | 10,371 |
hyperswitch-web
|
src/libraries/ua-parser-js/UAParser.res
|
.res
|
type browser = {name: option<string>, version: option<string>}
type os = {name: option<string>, version: option<string>}
type engine = {name: option<string>, version: option<string>}
type device = {model: option<string>, \"type": option<string>, vendor: option<string>}
type cpu = {architecture: option<string>}
type result = {
browser: browser,
os: os,
device: device,
engine: engine,
cpu: cpu,
}
@module("./ua-parser.js") external make: unit => result = "UAParser"
| 121 | 10,372 |
hyperswitch-web
|
src/libraries/ua-parser-js/ua-parser.js
|
.js
|
(function (window, undefined) {
"use strict";
var LIBVERSION = "2.0.0",
UA_MAX_LENGTH = 500,
USER_AGENT = "user-agent",
EMPTY = "",
UNKNOWN = "?",
FUNC_TYPE = "function",
UNDEF_TYPE = "undefined",
OBJ_TYPE = "object",
STR_TYPE = "string",
UA_BROWSER = "browser",
UA_CPU = "cpu",
UA_DEVICE = "device",
UA_ENGINE = "engine",
UA_OS = "os",
UA_RESULT = "result",
NAME = "name",
TYPE = "type",
VENDOR = "vendor",
VERSION = "version",
ARCHITECTURE = "architecture",
MAJOR = "major",
MODEL = "model",
CONSOLE = "console",
MOBILE = "mobile",
TABLET = "tablet",
SMARTTV = "smarttv",
WEARABLE = "wearable",
XR = "xr",
EMBEDDED = "embedded",
INAPP = "inapp",
BRANDS = "brands",
FORMFACTORS = "formFactors",
FULLVERLIST = "fullVersionList",
PLATFORM = "platform",
PLATFORMVER = "platformVersion",
BITNESS = "bitness",
CH_HEADER = "sec-ch-ua",
CH_HEADER_FULL_VER_LIST = CH_HEADER + "-full-version-list",
CH_HEADER_ARCH = CH_HEADER + "-arch",
CH_HEADER_BITNESS = CH_HEADER + "-" + BITNESS,
CH_HEADER_FORM_FACTORS = CH_HEADER + "-form-factors",
CH_HEADER_MOBILE = CH_HEADER + "-" + MOBILE,
CH_HEADER_MODEL = CH_HEADER + "-" + MODEL,
CH_HEADER_PLATFORM = CH_HEADER + "-" + PLATFORM,
CH_HEADER_PLATFORM_VER = CH_HEADER_PLATFORM + "-version",
CH_ALL_VALUES = [
BRANDS,
FULLVERLIST,
MOBILE,
MODEL,
PLATFORM,
PLATFORMVER,
ARCHITECTURE,
FORMFACTORS,
BITNESS,
],
AMAZON = "Amazon",
APPLE = "Apple",
ASUS = "ASUS",
BLACKBERRY = "BlackBerry",
GOOGLE = "Google",
HUAWEI = "Huawei",
LENOVO = "Lenovo",
HONOR = "Honor",
LG = "LG",
MICROSOFT = "Microsoft",
MOTOROLA = "Motorola",
NVIDIA = "Nvidia",
ONEPLUS = "OnePlus",
OPPO = "OPPO",
SAMSUNG = "Samsung",
SHARP = "Sharp",
SONY = "Sony",
XIAOMI = "Xiaomi",
ZEBRA = "Zebra",
CHROME = "Chrome",
CHROMIUM = "Chromium",
CHROMECAST = "Chromecast",
EDGE = "Edge",
FIREFOX = "Firefox",
OPERA = "Opera",
FACEBOOK = "Facebook",
SOGOU = "Sogou",
PREFIX_MOBILE = "Mobile ",
SUFFIX_BROWSER = " Browser",
WINDOWS = "Windows";
var isWindow = typeof window !== UNDEF_TYPE,
NAVIGATOR = isWindow && window.navigator ? window.navigator : undefined,
NAVIGATOR_UADATA =
NAVIGATOR && NAVIGATOR.userAgentData
? NAVIGATOR.userAgentData
: undefined;
var extend = function (defaultRgx, extensions) {
var mergedRgx = {};
var extraRgx = extensions;
if (!isExtensions(extensions)) {
extraRgx = {};
for (var i in extensions) {
for (var j in extensions[i]) {
extraRgx[j] = extensions[i][j].concat(
extraRgx[j] ? extraRgx[j] : []
);
}
}
}
for (var k in defaultRgx) {
mergedRgx[k] =
extraRgx[k] && extraRgx[k].length % 2 === 0
? extraRgx[k].concat(defaultRgx[k])
: defaultRgx[k];
}
return mergedRgx;
},
enumerize = function (arr) {
var enums = {};
for (var i = 0; i < arr.length; i++) {
enums[arr[i].toUpperCase()] = arr[i];
}
return enums;
},
has = function (str1, str2) {
if (typeof str1 === OBJ_TYPE && str1.length > 0) {
for (var i in str1) {
if (lowerize(str1[i]) == lowerize(str2)) return true;
}
return false;
}
return isString(str1)
? lowerize(str2).indexOf(lowerize(str1)) !== -1
: false;
},
isExtensions = function (obj, deep) {
for (var prop in obj) {
return (
/^(browser|cpu|device|engine|os)$/.test(prop) ||
(deep ? isExtensions(obj[prop]) : false)
);
}
},
isString = function (val) {
return typeof val === STR_TYPE;
},
itemListToArray = function (header) {
if (!header) return undefined;
var arr = [];
var tokens = strip(/\\?\"/g, header).split(",");
for (var i = 0; i < tokens.length; i++) {
if (tokens[i].indexOf(";") > -1) {
var token = trim(tokens[i]).split(";v=");
arr[i] = { brand: token[0], version: token[1] };
} else {
arr[i] = trim(tokens[i]);
}
}
return arr;
},
lowerize = function (str) {
return isString(str) ? str.toLowerCase() : str;
},
majorize = function (version) {
return isString(version)
? strip(/[^\d\.]/g, version).split(".")[0]
: undefined;
},
setProps = function (arr) {
for (var i in arr) {
var propName = arr[i];
if (typeof propName == OBJ_TYPE && propName.length == 2) {
this[propName[0]] = propName[1];
} else {
this[propName] = undefined;
}
}
return this;
},
strip = function (pattern, str) {
return isString(str) ? str.replace(pattern, EMPTY) : str;
},
stripQuotes = function (str) {
return strip(/\\?\"/g, str);
},
trim = function (str, len) {
if (isString(str)) {
str = strip(/^\s\s*/, str);
return typeof len === UNDEF_TYPE
? str
: str.substring(0, UA_MAX_LENGTH);
}
};
var rgxMapper = function (ua, arrays) {
if (!ua || !arrays) return;
var i = 0,
j,
k,
p,
q,
matches,
match;
while (i < arrays.length && !matches) {
var regex = arrays[i],
props = arrays[i + 1];
j = k = 0;
while (j < regex.length && !matches) {
if (!regex[j]) {
break;
}
matches = regex[j++].exec(ua);
if (!!matches) {
for (p = 0; p < props.length; p++) {
match = matches[++k];
q = props[p];
if (typeof q === OBJ_TYPE && q.length > 0) {
if (q.length === 2) {
if (typeof q[1] == FUNC_TYPE) {
this[q[0]] = q[1].call(this, match);
} else {
this[q[0]] = q[1];
}
} else if (q.length === 3) {
if (typeof q[1] === FUNC_TYPE && !(q[1].exec && q[1].test)) {
this[q[0]] = match
? q[1].call(this, match, q[2])
: undefined;
} else {
this[q[0]] = match ? match.replace(q[1], q[2]) : undefined;
}
} else if (q.length === 4) {
this[q[0]] = match
? q[3].call(this, match.replace(q[1], q[2]))
: undefined;
}
} else {
this[q] = match ? match : undefined;
}
}
}
}
i += 2;
}
},
strMapper = function (str, map) {
for (var i in map) {
if (typeof map[i] === OBJ_TYPE && map[i].length > 0) {
for (var j = 0; j < map[i].length; j++) {
if (has(map[i][j], str)) {
return i === UNKNOWN ? undefined : i;
}
}
} else if (has(map[i], str)) {
return i === UNKNOWN ? undefined : i;
}
}
return map.hasOwnProperty("*") ? map["*"] : str;
};
var windowsVersionMap = {
ME: "4.90",
"NT 3.11": "NT3.51",
"NT 4.0": "NT4.0",
2000: "NT 5.0",
XP: ["NT 5.1", "NT 5.2"],
Vista: "NT 6.0",
7: "NT 6.1",
8: "NT 6.2",
8.1: "NT 6.3",
10: ["NT 6.4", "NT 10.0"],
RT: "ARM",
},
formFactorsMap = {
embedded: "Automotive",
mobile: "Mobile",
tablet: ["Tablet", "EInk"],
smarttv: "TV",
wearable: "Watch",
xr: ["VR", "XR"],
"?": ["Desktop", "Unknown"],
"*": undefined,
};
var defaultRegexes = {
browser: [
[/\b(?:crmo|crios)\/([\w\.]+)/i],
[VERSION, [NAME, PREFIX_MOBILE + "Chrome"]],
[/edg(?:e|ios|a)?\/([\w\.]+)/i],
[VERSION, [NAME, "Edge"]],
[
/(opera mini)\/([-\w\.]+)/i,
/(opera [mobiletab]{3,6})\b.+version\/([-\w\.]+)/i,
/(opera)(?:.+version\/|[\/ ]+)([\w\.]+)/i,
],
[NAME, VERSION],
[/opios[\/ ]+([\w\.]+)/i],
[VERSION, [NAME, OPERA + " Mini"]],
[/\bop(?:rg)?x\/([\w\.]+)/i],
[VERSION, [NAME, OPERA + " GX"]],
[/\bopr\/([\w\.]+)/i],
[VERSION, [NAME, OPERA]],
[/\bb[ai]*d(?:uhd|[ub]*[aekoprswx]{5,6})[\/ ]?([\w\.]+)/i],
[VERSION, [NAME, "Baidu"]],
[/\b(?:mxbrowser|mxios|myie2)\/?([-\w\.]*)\b/i],
[VERSION, [NAME, "Maxthon"]],
[
/(kindle)\/([\w\.]+)/i,
/(lunascape|maxthon|netfront|jasmine|blazer|sleipnir)[\/ ]?([\w\.]*)/i,
/(avant|iemobile|slim(?:browser|boat|jet))[\/ ]?([\d\.]*)/i,
/(?:ms|\()(ie) ([\w\.]+)/i,
/(flock|rockmelt|midori|epiphany|silk|skyfire|ovibrowser|bolt|iron|vivaldi|iridium|phantomjs|bowser|qupzilla|falkon|rekonq|puffin|brave|whale(?!.+naver)|qqbrowserlite|duckduckgo|klar|helio|(?=comodo_)?dragon)\/([-\w\.]+)/i,
/(heytap|ovi|115)browser\/([\d\.]+)/i,
/(weibo)__([\d\.]+)/i,
],
[NAME, VERSION],
[/quark(?:pc)?\/([-\w\.]+)/i],
[VERSION, [NAME, "Quark"]],
[/\bddg\/([\w\.]+)/i],
[VERSION, [NAME, "DuckDuckGo"]],
[/(?:\buc? ?browser|(?:juc.+)ucweb)[\/ ]?([\w\.]+)/i],
[VERSION, [NAME, "UCBrowser"]],
[
/microm.+\bqbcore\/([\w\.]+)/i,
/\bqbcore\/([\w\.]+).+microm/i,
/micromessenger\/([\w\.]+)/i,
],
[VERSION, [NAME, "WeChat"]],
[/konqueror\/([\w\.]+)/i],
[VERSION, [NAME, "Konqueror"]],
[
/trident.+rv[: ]([\w\.]{1,9})\b.+like gecko/i, // IE11
],
[VERSION, [NAME, "IE"]],
[
/ya(?:search)?browser\/([\w\.]+)/i, // Yandex
],
[VERSION, [NAME, "Yandex"]],
[
/slbrowser\/([\w\.]+)/i, // Smart Lenovo Browser
],
[VERSION, [NAME, "Smart " + LENOVO + SUFFIX_BROWSER]],
[
/(avast|avg)\/([\w\.]+)/i, // Avast/AVG Secure Browser
],
[[NAME, /(.+)/, "$1 Secure" + SUFFIX_BROWSER], VERSION],
[
/\bfocus\/([\w\.]+)/i, // Firefox Focus
],
[VERSION, [NAME, FIREFOX + " Focus"]],
[
/\bopt\/([\w\.]+)/i, // Opera Touch
],
[VERSION, [NAME, OPERA + " Touch"]],
[
/coc_coc\w+\/([\w\.]+)/i, // Coc Coc Browser
],
[VERSION, [NAME, "Coc Coc"]],
[
/dolfin\/([\w\.]+)/i, // Dolphin
],
[VERSION, [NAME, "Dolphin"]],
[
/coast\/([\w\.]+)/i, // Opera Coast
],
[VERSION, [NAME, OPERA + " Coast"]],
[
/miuibrowser\/([\w\.]+)/i, // MIUI Browser
],
[VERSION, [NAME, "MIUI" + SUFFIX_BROWSER]],
[
/fxios\/([\w\.-]+)/i, // Firefox for iOS
],
[VERSION, [NAME, PREFIX_MOBILE + FIREFOX]],
[
/\bqihoobrowser\/?([\w\.]*)/i, // 360
],
[VERSION, [NAME, "360"]],
[
/\b(qq)\/([\w\.]+)/i, // QQ
],
[[NAME, /(.+)/, "$1Browser"], VERSION],
[/(oculus|sailfish|huawei|vivo|pico)browser\/([\w\.]+)/i],
[[NAME, /(.+)/, "$1" + SUFFIX_BROWSER], VERSION],
[
// Oculus/Sailfish/HuaweiBrowser/VivoBrowser/PicoBrowser
/samsungbrowser\/([\w\.]+)/i, // Samsung Internet
],
[VERSION, [NAME, SAMSUNG + " Internet"]],
[
/metasr[\/ ]?([\d\.]+)/i, // Sogou Explorer
],
[VERSION, [NAME, SOGOU + " Explorer"]],
[
/(sogou)mo\w+\/([\d\.]+)/i, // Sogou Mobile
],
[[NAME, SOGOU + " Mobile"], VERSION],
[
/(electron)\/([\w\.]+) safari/i, // Electron-based App
/(tesla)(?: qtcarbrowser|\/(20\d\d\.[-\w\.]+))/i, // Tesla
/m?(qqbrowser|2345(?=browser|chrome|explorer))\w*[\/ ]?v?([\w\.]+)/i, // QQ/2345
],
[NAME, VERSION],
[
/(lbbrowser|rekonq)/i, // LieBao Browser/Rekonq
],
[NAME],
[
/ome\/([\w\.]+) \w* ?(iron) saf/i, // Iron
/ome\/([\w\.]+).+qihu (360)[es]e/i, // 360
],
[VERSION, NAME],
[
// WebView
/((?:fban\/fbios|fb_iab\/fb4a)(?!.+fbav)|;fbav\/([\w\.]+);)/i, // Facebook App for iOS & Android
],
[[NAME, FACEBOOK], VERSION, [TYPE, INAPP]],
[
/(Klarna)\/([\w\.]+)/i, // Klarna Shopping Browser for iOS & Android
/(kakao(?:talk|story))[\/ ]([\w\.]+)/i, // Kakao App
/(naver)\(.*?(\d+\.[\w\.]+).*\)/i, // Naver InApp
/(daum)apps[\/ ]([\w\.]+)/i, // Daum App
/safari (line)\/([\w\.]+)/i, // Line App for iOS
/\b(line)\/([\w\.]+)\/iab/i, // Line App for Android
/(alipay)client\/([\w\.]+)/i, // Alipay
/(twitter)(?:and| f.+e\/([\w\.]+))/i, // Twitter
/(instagram|snapchat)[\/ ]([-\w\.]+)/i, // Instagram/Snapchat
],
[NAME, VERSION, [TYPE, INAPP]],
[
/\bgsa\/([\w\.]+) .*safari\//i, // Google Search Appliance on iOS
],
[VERSION, [NAME, "GSA"], [TYPE, INAPP]],
[
/musical_ly(?:.+app_?version\/|_)([\w\.]+)/i, // TikTok
],
[VERSION, [NAME, "TikTok"], [TYPE, INAPP]],
[
/\[(linkedin)app\]/i, // LinkedIn App for iOS & Android
],
[NAME, [TYPE, INAPP]],
[
/(chromium)[\/ ]([-\w\.]+)/i, // Chromium
],
[NAME, VERSION],
[
/headlesschrome(?:\/([\w\.]+)| )/i, // Chrome Headless
],
[VERSION, [NAME, CHROME + " Headless"]],
[
/ wv\).+(chrome)\/([\w\.]+)/i, // Chrome WebView
],
[[NAME, CHROME + " WebView"], VERSION],
[
/droid.+ version\/([\w\.]+)\b.+(?:mobile safari|safari)/i, // Android Browser
],
[VERSION, [NAME, "Android" + SUFFIX_BROWSER]],
[
/chrome\/([\w\.]+) mobile/i, // Chrome Mobile
],
[VERSION, [NAME, PREFIX_MOBILE + "Chrome"]],
[
/(chrome|omniweb|arora|[tizenoka]{5} ?browser)\/v?([\w\.]+)/i, // Chrome/OmniWeb/Arora/Tizen/Nokia
],
[NAME, VERSION],
[
/version\/([\w\.\,]+) .*mobile(?:\/\w+ | ?)safari/i, // Safari Mobile
],
[VERSION, [NAME, PREFIX_MOBILE + "Safari"]],
[/iphone .*mobile(?:\/\w+ | ?)safari/i],
[[NAME, PREFIX_MOBILE + "Safari"]],
[
/version\/([\w\.\,]+) .*(safari)/i, // Safari
],
[VERSION, NAME],
[
/webkit.+?(mobile ?safari|safari)(\/[\w\.]+)/i, // Safari < 3.0
],
[NAME, [VERSION, "1"]],
[/(webkit|khtml)\/([\w\.]+)/i],
[NAME, VERSION],
[
// Gecko based
/(?:mobile|tablet);.*(firefox)\/([\w\.-]+)/i, // Firefox Mobile
],
[[NAME, PREFIX_MOBILE + FIREFOX], VERSION],
[
/(navigator|netscape\d?)\/([-\w\.]+)/i, // Netscape
],
[[NAME, "Netscape"], VERSION],
[
/(wolvic|librewolf)\/([\w\.]+)/i, // Wolvic/LibreWolf
],
[NAME, VERSION],
[
/mobile vr; rv:([\w\.]+)\).+firefox/i, // Firefox Reality
],
[VERSION, [NAME, FIREFOX + " Reality"]],
[
/ekiohf.+(flow)\/([\w\.]+)/i, // Flow
/(swiftfox)/i, // Swiftfox
/(icedragon|iceweasel|camino|chimera|fennec|maemo browser|minimo|conkeror)[\/ ]?([\w\.\+]+)/i,
// IceDragon/Iceweasel/Camino/Chimera/Fennec/Maemo/Minimo/Conkeror
/(seamonkey|k-meleon|icecat|iceape|firebird|phoenix|palemoon|basilisk|waterfox)\/([-\w\.]+)$/i,
// Firefox/SeaMonkey/K-Meleon/IceCat/IceApe/Firebird/Phoenix
/(firefox)\/([\w\.]+)/i, // Other Firefox-based
/(mozilla)\/([\w\.]+) .+rv\:.+gecko\/\d+/i, // Mozilla
// Other
/(amaya|dillo|doris|icab|ladybird|lynx|mosaic|netsurf|obigo|polaris|w3m|(?:go|ice|up)[\. ]?browser)[-\/ ]?v?([\w\.]+)/i,
// Polaris/Lynx/Dillo/iCab/Doris/Amaya/w3m/NetSurf/Obigo/Mosaic/Go/ICE/UP.Browser/Ladybird
/\b(links) \(([\w\.]+)/i, // Links
],
[NAME, [VERSION, /_/g, "."]],
[
/(cobalt)\/([\w\.]+)/i, // Cobalt
],
[NAME, [VERSION, /[^\d\.]+./, EMPTY]],
],
cpu: [
[
/\b((amd|x|x86[-_]?|wow|win)64)\b/i, // AMD64 (x64)
],
[[ARCHITECTURE, "amd64"]],
[
/(ia32(?=;))/i, // IA32 (quicktime)
/\b((i[346]|x)86)\b/i, // IA32 (x86)
],
[[ARCHITECTURE, "ia32"]],
[
/\b(aarch64|arm(v?[89]e?l?|_?64))\b/i, // ARM64
],
[[ARCHITECTURE, "arm64"]],
[
/\b(arm(v[67])?ht?n?[fl]p?)\b/i, // ARMHF
],
[[ARCHITECTURE, "armhf"]],
[
// PocketPC mistakenly identified as PowerPC
/( (ce|mobile); ppc;|\/[\w\.]+arm\b)/i,
],
[[ARCHITECTURE, "arm"]],
[
/((ppc|powerpc)(64)?)( mac|;|\))/i, // PowerPC
],
[[ARCHITECTURE, /ower/, EMPTY, lowerize]],
[
/ sun4\w[;\)]/i, // SPARC
],
[[ARCHITECTURE, "sparc"]],
[
/\b(avr32|ia64(?=;)|68k(?=\))|\barm(?=v([1-7]|[5-7]1)l?|;|eabi)|(irix|mips|sparc)(64)?\b|pa-risc)/i,
// IA64, 68K, ARM/64, AVR/32, IRIX/64, MIPS/64, SPARC/64, PA-RISC
],
[[ARCHITECTURE, lowerize]],
],
device: [
[
/\b(sch-i[89]0\d|shw-m380s|sm-[ptx]\w{2,4}|gt-[pn]\d{2,4}|sgh-t8[56]9|nexus 10)/i,
],
[MODEL, [VENDOR, SAMSUNG], [TYPE, TABLET]],
[
/\b((?:s[cgp]h|gt|sm)-(?![lr])\w+|sc[g-]?[\d]+a?|galaxy nexus)/i,
/samsung[- ]((?!sm-[lr])[-\w]+)/i,
/sec-(sgh\w+)/i,
],
[MODEL, [VENDOR, SAMSUNG], [TYPE, MOBILE]],
[
// Apple
/(?:\/|\()(ip(?:hone|od)[\w, ]*)(?:\/|;)/i, // iPod/iPhone
],
[MODEL, [VENDOR, APPLE], [TYPE, MOBILE]],
[
/\((ipad);[-\w\),; ]+apple/i, // iPad
/applecoremedia\/[\w\.]+ \((ipad)/i,
/\b(ipad)\d\d?,\d\d?[;\]].+ios/i,
],
[MODEL, [VENDOR, APPLE], [TYPE, TABLET]],
[/(macintosh);/i],
[MODEL, [VENDOR, APPLE]],
[
// Sharp
/\b(sh-?[altvz]?\d\d[a-ekm]?)/i,
],
[MODEL, [VENDOR, SHARP], [TYPE, MOBILE]],
[
// Honor
/\b((?:brt|eln|hey2?|gdi|jdn)-a?[lnw]09|(?:ag[rm]3?|jdn2|kob2)-a?[lw]0[09]hn)(?: bui|\)|;)/i,
],
[MODEL, [VENDOR, HONOR], [TYPE, TABLET]],
[/honor([-\w ]+)[;\)]/i],
[MODEL, [VENDOR, HONOR], [TYPE, MOBILE]],
[
// Huawei
/\b((?:ag[rs][2356]?k?|bah[234]?|bg[2o]|bt[kv]|cmr|cpn|db[ry]2?|jdn2|got|kob2?k?|mon|pce|scm|sht?|[tw]gr|vrd)-[ad]?[lw][0125][09]b?|605hw|bg2-u03|(?:gem|fdr|m2|ple|t1)-[7a]0[1-4][lu]|t1-a2[13][lw]|mediapad[\w\. ]*(?= bui|\)))\b(?!.+d\/s)/i,
],
[MODEL, [VENDOR, HUAWEI], [TYPE, TABLET]],
[
/(?:huawei)([-\w ]+)[;\)]/i,
/\b(nexus 6p|\w{2,4}e?-[atu]?[ln][\dx][012359c][adn]?)\b(?!.+d\/s)/i,
],
[MODEL, [VENDOR, HUAWEI], [TYPE, MOBILE]],
[
// Xiaomi
/oid[^\)]+; (2[\dbc]{4}(182|283|rp\w{2})[cgl]|m2105k81a?c)(?: bui|\))/i,
/\b((?:red)?mi[-_ ]?pad[\w- ]*)(?: bui|\))/i, // Mi Pad tablets
],
[
[MODEL, /_/g, " "],
[VENDOR, XIAOMI],
[TYPE, TABLET],
],
[
/\b(poco[\w ]+|m2\d{3}j\d\d[a-z]{2})(?: bui|\))/i, // Xiaomi POCO
/\b; (\w+) build\/hm\1/i, // Xiaomi Hongmi 'numeric' models
/\b(hm[-_ ]?note?[_ ]?(?:\d\w)?) bui/i, // Xiaomi Hongmi
/\b(redmi[\-_ ]?(?:note|k)?[\w_ ]+)(?: bui|\))/i, // Xiaomi Redmi
/oid[^\)]+; (m?[12][0-389][01]\w{3,6}[c-y])( bui|; wv|\))/i, // Xiaomi Redmi 'numeric' models
/\b(mi[-_ ]?(?:a\d|one|one[_ ]plus|note lte|max|cc)?[_ ]?(?:\d?\w?)[_ ]?(?:plus|se|lite|pro)?)(?: bui|\))/i, // Xiaomi Mi
/ ([\w ]+) miui\/v?\d/i,
],
[
[MODEL, /_/g, " "],
[VENDOR, XIAOMI],
[TYPE, MOBILE],
],
[
// OPPO
/; (\w+) bui.+ oppo/i,
/\b(cph[12]\d{3}|p(?:af|c[al]|d\w|e[ar])[mt]\d0|x9007|a101op)\b/i,
],
[MODEL, [VENDOR, OPPO], [TYPE, MOBILE]],
[/\b(opd2(\d{3}a?))(?: bui|\))/i],
[
MODEL,
[VENDOR, strMapper, { OnePlus: ["304", "403", "203"], "*": OPPO }],
[TYPE, TABLET],
],
[
// Vivo
/vivo (\w+)(?: bui|\))/i,
/\b(v[12]\d{3}\w?[at])(?: bui|;)/i,
],
[MODEL, [VENDOR, "Vivo"], [TYPE, MOBILE]],
[
// Realme
/\b(rmx[1-3]\d{3})(?: bui|;|\))/i,
],
[MODEL, [VENDOR, "Realme"], [TYPE, MOBILE]],
[
// Motorola
/\b(milestone|droid(?:[2-4x]| (?:bionic|x2|pro|razr))?:?( 4g)?)\b[\w ]+build\//i,
/\bmot(?:orola)?[- ](\w*)/i,
/((?:moto(?! 360)[\w\(\) ]+|xt\d{3,4}|nexus 6)(?= bui|\)))/i,
],
[MODEL, [VENDOR, MOTOROLA], [TYPE, MOBILE]],
[/\b(mz60\d|xoom[2 ]{0,2}) build\//i],
[MODEL, [VENDOR, MOTOROLA], [TYPE, TABLET]],
[
// LG
/((?=lg)?[vl]k\-?\d{3}) bui| 3\.[-\w; ]{10}lg?-([06cv9]{3,4})/i,
],
[MODEL, [VENDOR, LG], [TYPE, TABLET]],
[
/(lm(?:-?f100[nv]?|-[\w\.]+)(?= bui|\))|nexus [45])/i,
/\blg[-e;\/ ]+((?!browser|netcast|android tv|watch)\w+)/i,
/\blg-?([\d\w]+) bui/i,
],
[MODEL, [VENDOR, LG], [TYPE, MOBILE]],
[
// Lenovo
/(ideatab[-\w ]+|602lv|d-42a|a101lv|a2109a|a3500-hv|s[56]000|pb-6505[my]|tb-?x?\d{3,4}(?:f[cu]|xu|[av])|yt\d?-[jx]?\d+[lfmx])( bui|;|\)|\/)/i,
/lenovo ?(b[68]0[08]0-?[hf]?|tab(?:[\w- ]+?)|tb[\w-]{6,7})( bui|;|\)|\/)/i,
],
[MODEL, [VENDOR, LENOVO], [TYPE, TABLET]],
[
// Nokia
/(nokia) (t[12][01])/i,
],
[VENDOR, MODEL, [TYPE, TABLET]],
[/(?:maemo|nokia).*(n900|lumia \d+)/i, /nokia[-_ ]?(([-\w\.]*))/i],
[
[MODEL, /_/g, " "],
[TYPE, MOBILE],
[VENDOR, "Nokia"],
],
[
// Google
/(pixel (c|tablet))\b/i, // Google Pixel C/Tablet
],
[MODEL, [VENDOR, GOOGLE], [TYPE, TABLET]],
[
/droid.+; (pixel[\daxl ]{0,6})(?: bui|\))/i, // Google Pixel
],
[MODEL, [VENDOR, GOOGLE], [TYPE, MOBILE]],
[
// Sony
/droid.+; (a?\d[0-2]{2}so|[c-g]\d{4}|so[-gl]\w+|xq-a\w[4-7][12])(?= bui|\).+chrome\/(?![1-6]{0,1}\d\.))/i,
],
[MODEL, [VENDOR, SONY], [TYPE, MOBILE]],
[/sony tablet [ps]/i, /\b(?:sony)?sgp\w+(?: bui|\))/i],
[
[MODEL, "Xperia Tablet"],
[VENDOR, SONY],
[TYPE, TABLET],
],
[
// OnePlus
/ (kb2005|in20[12]5|be20[12][59])\b/i,
/(?:one)?(?:plus)? (a\d0\d\d)(?: b|\))/i,
],
[MODEL, [VENDOR, ONEPLUS], [TYPE, MOBILE]],
[
// Amazon
/(alexa)webm/i,
/(kf[a-z]{2}wi|aeo(?!bc)\w\w)( bui|\))/i, // Kindle Fire without Silk / Echo Show
/(kf[a-z]+)( bui|\)).+silk\//i, // Kindle Fire HD
],
[MODEL, [VENDOR, AMAZON], [TYPE, TABLET]],
[
/((?:sd|kf)[0349hijorstuw]+)( bui|\)).+silk\//i, // Fire Phone
],
[
[MODEL, /(.+)/g, "Fire Phone $1"],
[VENDOR, AMAZON],
[TYPE, MOBILE],
],
[
// BlackBerry
/(playbook);[-\w\),; ]+(rim)/i, // BlackBerry PlayBook
],
[MODEL, VENDOR, [TYPE, TABLET]],
[
/\b((?:bb[a-f]|st[hv])100-\d)/i,
/\(bb10; (\w+)/i, // BlackBerry 10
],
[MODEL, [VENDOR, BLACKBERRY], [TYPE, MOBILE]],
[
// Asus
/(?:\b|asus_)(transfo[prime ]{4,10} \w+|eeepc|slider \w+|nexus 7|padfone|p00[cj])/i,
],
[MODEL, [VENDOR, ASUS], [TYPE, TABLET]],
[/ (z[bes]6[027][012][km][ls]|zenfone \d\w?)\b/i],
[MODEL, [VENDOR, ASUS], [TYPE, MOBILE]],
[
// HTC
/(nexus 9)/i, // HTC Nexus 9
],
[MODEL, [VENDOR, "HTC"], [TYPE, TABLET]],
[
/(htc)[-;_ ]{1,2}([\w ]+(?=\)| bui)|\w+)/i, // HTC
// ZTE
/(zte)[- ]([\w ]+?)(?: bui|\/|\))/i,
/(alcatel|geeksphone|nexian|panasonic(?!(?:;|\.))|sony(?!-bra))[-_ ]?([-\w]*)/i, // Alcatel/GeeksPhone/Nexian/Panasonic/Sony
],
[VENDOR, [MODEL, /_/g, " "], [TYPE, MOBILE]],
[
// TCL
/tcl (xess p17aa)/i,
/droid [\w\.]+; ((?:8[14]9[16]|9(?:0(?:48|60|8[01])|1(?:3[27]|66)|2(?:6[69]|9[56])|466))[gqswx])(_\w(\w|\w\w))?(\)| bui)/i,
],
[MODEL, [VENDOR, "TCL"], [TYPE, TABLET]],
[
/droid [\w\.]+; (418(?:7d|8v)|5087z|5102l|61(?:02[dh]|25[adfh]|27[ai]|56[dh]|59k|65[ah])|a509dl|t(?:43(?:0w|1[adepqu])|50(?:6d|7[adju])|6(?:09dl|10k|12b|71[efho]|76[hjk])|7(?:66[ahju]|67[hw]|7[045][bh]|71[hk]|73o|76[ho]|79w|81[hks]?|82h|90[bhsy]|99b)|810[hs]))(_\w(\w|\w\w))?(\)| bui)/i,
],
[MODEL, [VENDOR, "TCL"], [TYPE, MOBILE]],
[
// itel
/(itel) ((\w+))/i,
],
[
[VENDOR, lowerize],
MODEL,
[TYPE, strMapper, { tablet: ["p10001l", "w7001"], "*": "mobile" }],
],
[
// Acer
/droid.+; ([ab][1-7]-?[0178a]\d\d?)/i,
],
[MODEL, [VENDOR, "Acer"], [TYPE, TABLET]],
[
// Meizu
/droid.+; (m[1-5] note) bui/i,
/\bmz-([-\w]{2,})/i,
],
[MODEL, [VENDOR, "Meizu"], [TYPE, MOBILE]],
[
// Ulefone
/; ((?:power )?armor(?:[\w ]{0,8}))(?: bui|\))/i,
],
[MODEL, [VENDOR, "Ulefone"], [TYPE, MOBILE]],
[
// Energizer
/; (energy ?\w+)(?: bui|\))/i,
/; energizer ([\w ]+)(?: bui|\))/i,
],
[MODEL, [VENDOR, "Energizer"], [TYPE, MOBILE]],
[
// Cat
/; cat (b35);/i,
/; (b15q?|s22 flip|s48c|s62 pro)(?: bui|\))/i,
],
[MODEL, [VENDOR, "Cat"], [TYPE, MOBILE]],
[
// Smartfren
/((?:new )?andromax[\w- ]+)(?: bui|\))/i,
],
[MODEL, [VENDOR, "Smartfren"], [TYPE, MOBILE]],
[
// Nothing
/droid.+; (a(?:015|06[35]|142p?))/i,
],
[MODEL, [VENDOR, "Nothing"], [TYPE, MOBILE]],
[
// MIXED
/(imo) (tab \w+)/i, // IMO
/(infinix) (x1101b?)/i, // Infinix XPad
],
[VENDOR, MODEL, [TYPE, TABLET]],
[
/(blackberry|benq|palm(?=\-)|sonyericsson|acer|asus(?! zenw)|dell|jolla|meizu|motorola|polytron|infinix|tecno|micromax|advan)[-_ ]?([-\w]*)/i,
/; (hmd|imo) ([\w ]+?)(?: bui|\))/i, // HMD/IMO
/(hp) ([\w ]+\w)/i, // HP iPAQ
/(microsoft); (lumia[\w ]+)/i, // Microsoft Lumia
/(lenovo)[-_ ]?([-\w ]+?)(?: bui|\)|\/)/i, // Lenovo
/(oppo) ?([\w ]+) bui/i, // OPPO
],
[VENDOR, MODEL, [TYPE, MOBILE]],
[
/(kobo)\s(ereader|touch)/i, // Kobo
/(archos) (gamepad2?)/i, // Archos
/(hp).+(touchpad(?!.+tablet)|tablet)/i, // HP TouchPad
/(kindle)\/([\w\.]+)/i, // Kindle
],
[VENDOR, MODEL, [TYPE, TABLET]],
[
/(surface duo)/i, // Surface Duo
],
[MODEL, [VENDOR, MICROSOFT], [TYPE, TABLET]],
[
/droid [\d\.]+; (fp\du?)(?: b|\))/i, // Fairphone
],
[MODEL, [VENDOR, "Fairphone"], [TYPE, MOBILE]],
[
/((?:tegranote|shield t(?!.+d tv))[\w- ]*?)(?: b|\))/i, // Nvidia Tablets
],
[MODEL, [VENDOR, NVIDIA], [TYPE, TABLET]],
[
/(sprint) (\w+)/i, // Sprint Phones
],
[VENDOR, MODEL, [TYPE, MOBILE]],
[
/(kin\.[onetw]{3})/i, // Microsoft Kin
],
[
[MODEL, /\./g, " "],
[VENDOR, MICROSOFT],
[TYPE, MOBILE],
],
[
/droid.+; ([c6]+|et5[16]|mc[239][23]x?|vc8[03]x?)\)/i, // Zebra
],
[MODEL, [VENDOR, ZEBRA], [TYPE, TABLET]],
[/droid.+; (ec30|ps20|tc[2-8]\d[kx])\)/i],
[MODEL, [VENDOR, ZEBRA], [TYPE, MOBILE]],
[
/smart-tv.+(samsung)/i, // Samsung
],
[VENDOR, [TYPE, SMARTTV]],
[/hbbtv.+maple;(\d+)/i],
[
[MODEL, /^/, "SmartTV"],
[VENDOR, SAMSUNG],
[TYPE, SMARTTV],
],
[
/(nux; netcast.+smarttv|lg (netcast\.tv-201\d|android tv))/i, // LG SmartTV
],
[
[VENDOR, LG],
[TYPE, SMARTTV],
],
[
/(apple) ?tv/i, // Apple TV
],
[VENDOR, [MODEL, APPLE + " TV"], [TYPE, SMARTTV]],
[
/crkey.*devicetype\/chromecast/i, // Google Chromecast Third Generation
],
[
[MODEL, CHROMECAST + " Third Generation"],
[VENDOR, GOOGLE],
[TYPE, SMARTTV],
],
[
/crkey.*devicetype\/([^/]*)/i, // Google Chromecast with specific device type
],
[
[MODEL, /^/, "Chromecast "],
[VENDOR, GOOGLE],
[TYPE, SMARTTV],
],
[
/fuchsia.*crkey/i, // Google Chromecast Nest Hub
],
[
[MODEL, CHROMECAST + " Nest Hub"],
[VENDOR, GOOGLE],
[TYPE, SMARTTV],
],
[
/crkey/i, // Google Chromecast, Linux-based or unknown
],
[
[MODEL, CHROMECAST],
[VENDOR, GOOGLE],
[TYPE, SMARTTV],
],
[
/droid.+aft(\w+)( bui|\))/i, // Fire TV
],
[MODEL, [VENDOR, AMAZON], [TYPE, SMARTTV]],
[
/(shield \w+ tv)/i, // Nvidia Shield TV
],
[MODEL, [VENDOR, NVIDIA], [TYPE, SMARTTV]],
[
/\(dtv[\);].+(aquos)/i,
/(aquos-tv[\w ]+)\)/i, // Sharp
],
[MODEL, [VENDOR, SHARP], [TYPE, SMARTTV]],
[
/(bravia[\w ]+)( bui|\))/i, // Sony
],
[MODEL, [VENDOR, SONY], [TYPE, SMARTTV]],
[
/(mi(tv|box)-?\w+) bui/i, // Xiaomi
],
[MODEL, [VENDOR, XIAOMI], [TYPE, SMARTTV]],
[
/Hbbtv.*(technisat) (.*);/i, // TechniSAT
],
[VENDOR, MODEL, [TYPE, SMARTTV]],
[
/\b(roku)[\dx]*[\)\/]((?:dvp-)?[\d\.]*)/i, // Roku
/hbbtv\/\d+\.\d+\.\d+ +\([\w\+ ]*; *([\w\d][^;]*);([^;]*)/i, // HbbTV devices
],
[
[VENDOR, trim],
[MODEL, trim],
[TYPE, SMARTTV],
],
[/droid.+; ([\w- ]+) (?:android tv|smart[- ]?tv)/i],
[MODEL, [TYPE, SMARTTV]],
[/\b(android tv|smart[- ]?tv|opera tv|tv; rv:)\b/i],
[[TYPE, SMARTTV]],
[
/(ouya)/i, // Ouya
/(nintendo) (\w+)/i, // Nintendo
],
[VENDOR, MODEL, [TYPE, CONSOLE]],
[
/droid.+; (shield)( bui|\))/i, // Nvidia Portable
],
[MODEL, [VENDOR, NVIDIA], [TYPE, CONSOLE]],
[
/(playstation \w+)/i, // Playstation
],
[MODEL, [VENDOR, SONY], [TYPE, CONSOLE]],
[
/\b(xbox(?: one)?(?!; xbox))[\); ]/i, // Microsoft Xbox
],
[MODEL, [VENDOR, MICROSOFT], [TYPE, CONSOLE]],
[
/\b(sm-[lr]\d\d[0156][fnuw]?s?|gear live)\b/i, // Samsung Galaxy Watch
],
[MODEL, [VENDOR, SAMSUNG], [TYPE, WEARABLE]],
[
/((pebble))app/i, // Pebble
/(asus|google|lg|oppo) ((pixel |zen)?watch[\w ]*)( bui|\))/i, // Asus ZenWatch / LG Watch / Pixel Watch
],
[VENDOR, MODEL, [TYPE, WEARABLE]],
[
/(ow(?:19|20)?we?[1-3]{1,3})/i, // Oppo Watch
],
[MODEL, [VENDOR, OPPO], [TYPE, WEARABLE]],
[
/(watch)(?: ?os[,\/]|\d,\d\/)[\d\.]+/i, // Apple Watch
],
[MODEL, [VENDOR, APPLE], [TYPE, WEARABLE]],
[
/(opwwe\d{3})/i, // OnePlus Watch
],
[MODEL, [VENDOR, ONEPLUS], [TYPE, WEARABLE]],
[
/(moto 360)/i, // Motorola 360
],
[MODEL, [VENDOR, MOTOROLA], [TYPE, WEARABLE]],
[
/(smartwatch 3)/i, // Sony SmartWatch
],
[MODEL, [VENDOR, SONY], [TYPE, WEARABLE]],
[
/(g watch r)/i, // LG G Watch R
],
[MODEL, [VENDOR, LG], [TYPE, WEARABLE]],
[/droid.+; (wt63?0{2,3})\)/i],
[MODEL, [VENDOR, ZEBRA], [TYPE, WEARABLE]],
[
/droid.+; (glass) \d/i, // Google Glass
],
[MODEL, [VENDOR, GOOGLE], [TYPE, XR]],
[
/(pico) (4|neo3(?: link|pro)?)/i, // Pico
],
[VENDOR, MODEL, [TYPE, XR]],
[
/; (quest( \d| pro)?)/i, // Oculus Quest
],
[MODEL, [VENDOR, FACEBOOK], [TYPE, XR]],
[
/(tesla)(?: qtcarbrowser|\/[-\w\.]+)/i, // Tesla
],
[VENDOR, [TYPE, EMBEDDED]],
[
/(aeobc)\b/i, // Echo Dot
],
[MODEL, [VENDOR, AMAZON], [TYPE, EMBEDDED]],
[
/(homepod).+mac os/i, // Apple HomePod
],
[MODEL, [VENDOR, APPLE], [TYPE, EMBEDDED]],
[/windows iot/i],
[[TYPE, EMBEDDED]],
[/droid .+?; ([^;]+?)(?: bui|; wv\)|\) applew).+?(mobile|vr|\d) safari/i],
[MODEL, [TYPE, strMapper, { mobile: "Mobile", xr: "VR", "*": TABLET }]],
[
/\b((tablet|tab)[;\/]|focus\/\d(?!.+mobile))/i, // Unidentifiable Tablet
],
[[TYPE, TABLET]],
[
/(phone|mobile(?:[;\/]| [ \w\/\.]*safari)|pda(?=.+windows ce))/i, // Unidentifiable Mobile
],
[[TYPE, MOBILE]],
[
/droid .+?; ([\w\. -]+)( bui|\))/i, // Generic Android Device
],
[MODEL, [VENDOR, "Generic"]],
],
engine: [
[
/windows.+ edge\/([\w\.]+)/i, // EdgeHTML
],
[VERSION, [NAME, EDGE + "HTML"]],
[
/(arkweb)\/([\w\.]+)/i, // ArkWeb
],
[NAME, VERSION],
[
/webkit\/537\.36.+chrome\/(?!27)([\w\.]+)/i, // Blink
],
[VERSION, [NAME, "Blink"]],
[
/(presto)\/([\w\.]+)/i, // Presto
/(webkit|trident|netfront|netsurf|amaya|lynx|w3m|goanna|servo)\/([\w\.]+)/i, // WebKit/Trident/NetFront/NetSurf/Amaya/Lynx/w3m/Goanna/Servo
/ekioh(flow)\/([\w\.]+)/i, // Flow
/(khtml|tasman|links)[\/ ]\(?([\w\.]+)/i, // KHTML/Tasman/Links
/(icab)[\/ ]([23]\.[\d\.]+)/i, // iCab
/\b(libweb)/i, // LibWeb
],
[NAME, VERSION],
[/ladybird\//i],
[[NAME, "LibWeb"]],
[
/rv\:([\w\.]{1,9})\b.+(gecko)/i, // Gecko
],
[VERSION, NAME],
],
os: [
[
// Windows
/microsoft (windows) (vista|xp)/i, // Windows (iTunes)
],
[NAME, VERSION],
[
/(windows (?:phone(?: os)?|mobile|iot))[\/ ]?([\d\.\w ]*)/i, // Windows Phone
],
[NAME, [VERSION, strMapper, windowsVersionMap]],
[
/windows nt 6\.2; (arm)/i, // Windows RT
/windows[\/ ]([ntce\d\. ]+\w)(?!.+xbox)/i,
/(?:win(?=3|9|n)|win 9x )([nt\d\.]+)/i,
],
[
[VERSION, strMapper, windowsVersionMap],
[NAME, WINDOWS],
],
[
// iOS/macOS
/[adehimnop]{4,7}\b(?:.*os ([\w]+) like mac|; opera)/i, // iOS
/(?:ios;fbsv\/|iphone.+ios[\/ ])([\d\.]+)/i,
/cfnetwork\/.+darwin/i,
],
[
[VERSION, /_/g, "."],
[NAME, "iOS"],
],
[
/(mac os x) ?([\w\. ]*)/i,
/(macintosh|mac_powerpc\b)(?!.+haiku)/i, // Mac OS
],
[
[NAME, "macOS"],
[VERSION, /_/g, "."],
],
[
// Google Chromecast
/android ([\d\.]+).*crkey/i, // Google Chromecast, Android-based
],
[VERSION, [NAME, CHROMECAST + " Android"]],
[
/fuchsia.*crkey\/([\d\.]+)/i, // Google Chromecast, Fuchsia-based
],
[VERSION, [NAME, CHROMECAST + " Fuchsia"]],
[
/crkey\/([\d\.]+).*devicetype\/smartspeaker/i, // Google Chromecast, Linux-based Smart Speaker
],
[VERSION, [NAME, CHROMECAST + " SmartSpeaker"]],
[
/linux.*crkey\/([\d\.]+)/i, // Google Chromecast, Legacy Linux-based
],
[VERSION, [NAME, CHROMECAST + " Linux"]],
[
/crkey\/([\d\.]+)/i, // Google Chromecast, unknown
],
[VERSION, [NAME, CHROMECAST]],
[
// Mobile OSes
/droid ([\w\.]+)\b.+(android[- ]x86|harmonyos)/i, // Android-x86/HarmonyOS
],
[VERSION, NAME],
[
/(ubuntu) ([\w\.]+) like android/i, // Ubuntu Touch
],
[[NAME, /(.+)/, "$1 Touch"], VERSION],
[
// Android/WebOS/QNX/Bada/RIM/Maemo/MeeGo/Sailfish OS/OpenHarmony
/(android|webos|qnx|bada|rim tablet os|maemo|meego|sailfish|openharmony)[-\/ ]?([\w\.]*)/i,
/(blackberry)\w*\/([\w\.]*)/i, // Blackberry
/(tizen|kaios)[\/ ]([\w\.]+)/i, // Tizen/KaiOS
/\((series40);/i, // Series 40
],
[NAME, VERSION],
[
/\(bb(10);/i, // BlackBerry 10
],
[VERSION, [NAME, BLACKBERRY]],
[
/(?:symbian ?os|symbos|s60(?=;)|series60)[-\/ ]?([\w\.]*)/i, // Symbian
],
[VERSION, [NAME, "Symbian"]],
[
/mozilla\/[\d\.]+ \((?:mobile|tablet|tv|mobile; [\w ]+); rv:.+ gecko\/([\w\.]+)/i, // Firefox OS
],
[VERSION, [NAME, FIREFOX + " OS"]],
[
/web0s;.+rt(tv)/i,
/\b(?:hp)?wos(?:browser)?\/([\w\.]+)/i, // WebOS
],
[VERSION, [NAME, "webOS"]],
[
/watch(?: ?os[,\/]|\d,\d\/)([\d\.]+)/i, // watchOS
],
[VERSION, [NAME, "watchOS"]],
[
// Google ChromeOS
/(cros) [\w]+(?:\)| ([\w\.]+)\b)/i, // Chromium OS
],
[[NAME, "Chrome OS"], VERSION],
[
// Smart TVs
/panasonic;(viera)/i, // Panasonic Viera
/(netrange)mmh/i, // Netrange
/(nettv)\/(\d+\.[\w\.]+)/i, // NetTV
// Console
/(nintendo|playstation) (\w+)/i, // Nintendo/Playstation
/(xbox); +xbox ([^\);]+)/i, // Microsoft Xbox (360, One, X, S, Series X, Series S)
/(pico) .+os([\w\.]+)/i, // Pico
// Other
/\b(joli|palm)\b ?(?:os)?\/?([\w\.]*)/i, // Joli/Palm
/(mint)[\/\(\) ]?(\w*)/i, // Mint
/(mageia|vectorlinux)[; ]/i, // Mageia/VectorLinux
/([kxln]?ubuntu|debian|suse|opensuse|gentoo|arch(?= linux)|slackware|fedora|mandriva|centos|pclinuxos|red ?hat|zenwalk|linpus|raspbian|plan 9|minix|risc os|contiki|deepin|manjaro|elementary os|sabayon|linspire)(?: gnu\/linux)?(?: enterprise)?(?:[- ]linux)?(?:-gnu)?[-\/ ]?(?!chrom|package)([-\w\.]*)/i,
// Ubuntu/Debian/SUSE/Gentoo/Arch/Slackware/Fedora/Mandriva/CentOS/PCLinuxOS/RedHat/Zenwalk/Linpus/Raspbian/Plan9/Minix/RISCOS/Contiki/Deepin/Manjaro/elementary/Sabayon/Linspire
/(hurd|linux) ?([\w\.]*)/i, // Hurd/Linux
/(gnu) ?([\w\.]*)/i, // GNU
/\b([-frentopcghs]{0,5}bsd|dragonfly)[\/ ]?(?!amd|[ix346]{1,2}86)([\w\.]*)/i, // FreeBSD/NetBSD/OpenBSD/PC-BSD/GhostBSD/DragonFly
/(haiku) (\w+)/i, // Haiku
],
[NAME, VERSION],
[
/(sunos) ?([\w\.\d]*)/i, // Solaris
],
[[NAME, "Solaris"], VERSION],
[
/((?:open)?solaris)[-\/ ]?([\w\.]*)/i, // Solaris
/(aix) ((\d)(?=\.|\)| )[\w\.])*/i, // AIX
/\b(beos|os\/2|amigaos|morphos|openvms|fuchsia|hp-ux|serenityos)/i, // BeOS/OS2/AmigaOS/MorphOS/OpenVMS/Fuchsia/HP-UX/SerenityOS
/(unix) ?([\w\.]*)/i, // UNIX
],
[NAME, VERSION],
],
};
var defaultProps = (function () {
var props = { init: {}, isIgnore: {}, isIgnoreRgx: {}, toString: {} };
setProps.call(props.init, [
[UA_BROWSER, [NAME, VERSION, MAJOR, TYPE]],
[UA_CPU, [ARCHITECTURE]],
[UA_DEVICE, [TYPE, MODEL, VENDOR]],
[UA_ENGINE, [NAME, VERSION]],
[UA_OS, [NAME, VERSION]],
]);
setProps.call(props.isIgnore, [
[UA_BROWSER, [VERSION, MAJOR]],
[UA_ENGINE, [VERSION]],
[UA_OS, [VERSION]],
]);
setProps.call(props.isIgnoreRgx, [
[UA_BROWSER, / ?browser$/i],
[UA_OS, / ?os$/i],
]);
setProps.call(props.toString, [
[UA_BROWSER, [NAME, VERSION]],
[UA_CPU, [ARCHITECTURE]],
[UA_DEVICE, [VENDOR, MODEL]],
[UA_ENGINE, [NAME, VERSION]],
[UA_OS, [NAME, VERSION]],
]);
return props;
})();
var createIData = function (item, itemType) {
var init_props = defaultProps.init[itemType],
is_ignoreProps = defaultProps.isIgnore[itemType] || 0,
is_ignoreRgx = defaultProps.isIgnoreRgx[itemType] || 0,
toString_props = defaultProps.toString[itemType] || 0;
function IData() {
setProps.call(this, init_props);
}
IData.prototype.getItem = function () {
return item;
};
IData.prototype.withClientHints = function () {
if (!NAVIGATOR_UADATA) {
return item.parseCH().get();
}
return NAVIGATOR_UADATA.getHighEntropyValues(CH_ALL_VALUES).then(
function (res) {
return item.setCH(new UACHData(res, false)).parseCH().get();
}
);
};
IData.prototype.withFeatureCheck = function () {
return item.detectFeature().get();
};
if (itemType != UA_RESULT) {
IData.prototype.is = function (strToCheck) {
var is = false;
for (var i in this) {
if (
this.hasOwnProperty(i) &&
!has(is_ignoreProps, i) &&
lowerize(is_ignoreRgx ? strip(is_ignoreRgx, this[i]) : this[i]) ==
lowerize(
is_ignoreRgx ? strip(is_ignoreRgx, strToCheck) : strToCheck
)
) {
is = true;
if (strToCheck != UNDEF_TYPE) break;
} else if (strToCheck == UNDEF_TYPE && is) {
is = !is;
break;
}
}
return is;
};
IData.prototype.toString = function () {
var str = EMPTY;
for (var i in toString_props) {
if (typeof this[toString_props[i]] !== UNDEF_TYPE) {
str += (str ? " " : EMPTY) + this[toString_props[i]];
}
}
return str || UNDEF_TYPE;
};
}
if (!NAVIGATOR_UADATA) {
IData.prototype.then = function (cb) {
var that = this;
var IDataResolve = function () {
for (var prop in that) {
if (that.hasOwnProperty(prop)) {
this[prop] = that[prop];
}
}
};
IDataResolve.prototype = {
is: IData.prototype.is,
toString: IData.prototype.toString,
};
var resolveData = new IDataResolve();
cb(resolveData);
return resolveData;
};
}
return new IData();
};
function UACHData(uach, isHttpUACH) {
uach = uach || {};
setProps.call(this, CH_ALL_VALUES);
if (isHttpUACH) {
setProps.call(this, [
[BRANDS, itemListToArray(uach[CH_HEADER])],
[FULLVERLIST, itemListToArray(uach[CH_HEADER_FULL_VER_LIST])],
[MOBILE, /\?1/.test(uach[CH_HEADER_MOBILE])],
[MODEL, stripQuotes(uach[CH_HEADER_MODEL])],
[PLATFORM, stripQuotes(uach[CH_HEADER_PLATFORM])],
[PLATFORMVER, stripQuotes(uach[CH_HEADER_PLATFORM_VER])],
[ARCHITECTURE, stripQuotes(uach[CH_HEADER_ARCH])],
[FORMFACTORS, itemListToArray(uach[CH_HEADER_FORM_FACTORS])],
[BITNESS, stripQuotes(uach[CH_HEADER_BITNESS])],
]);
} else {
for (var prop in uach) {
if (this.hasOwnProperty(prop) && typeof uach[prop] !== UNDEF_TYPE)
this[prop] = uach[prop];
}
}
}
function UAItem(itemType, ua, rgxMap, uaCH) {
this.get = function (prop) {
if (!prop) return this.data;
return this.data.hasOwnProperty(prop) ? this.data[prop] : undefined;
};
this.set = function (prop, val) {
this.data[prop] = val;
return this;
};
this.setCH = function (ch) {
this.uaCH = ch;
return this;
};
this.detectFeature = function () {
if (NAVIGATOR && NAVIGATOR.userAgent == this.ua) {
switch (this.itemType) {
case UA_BROWSER:
if (
NAVIGATOR.brave &&
typeof NAVIGATOR.brave.isBrave == FUNC_TYPE
) {
this.set(NAME, "Brave");
}
break;
case UA_DEVICE:
if (
!this.get(TYPE) &&
NAVIGATOR_UADATA &&
NAVIGATOR_UADATA[MOBILE]
) {
this.set(TYPE, MOBILE);
}
if (
this.get(MODEL) == "Macintosh" &&
NAVIGATOR &&
typeof NAVIGATOR.standalone !== UNDEF_TYPE &&
NAVIGATOR.maxTouchPoints &&
NAVIGATOR.maxTouchPoints > 2
) {
this.set(MODEL, "iPad").set(TYPE, TABLET);
}
break;
case UA_OS:
if (
!this.get(NAME) &&
NAVIGATOR_UADATA &&
NAVIGATOR_UADATA[PLATFORM]
) {
this.set(NAME, NAVIGATOR_UADATA[PLATFORM]);
}
break;
case UA_RESULT:
var data = this.data;
var detect = function (itemType) {
return data[itemType].getItem().detectFeature().get();
};
this.set(UA_BROWSER, detect(UA_BROWSER))
.set(UA_CPU, detect(UA_CPU))
.set(UA_DEVICE, detect(UA_DEVICE))
.set(UA_ENGINE, detect(UA_ENGINE))
.set(UA_OS, detect(UA_OS));
}
}
return this;
};
this.parseUA = function () {
if (this.itemType != UA_RESULT) {
rgxMapper.call(this.data, this.ua, this.rgxMap);
}
if (this.itemType == UA_BROWSER) {
this.set(MAJOR, majorize(this.get(VERSION)));
}
return this;
};
this.parseCH = function () {
var uaCH = this.uaCH,
rgxMap = this.rgxMap;
switch (this.itemType) {
case UA_BROWSER:
case UA_ENGINE:
var brands = uaCH[FULLVERLIST] || uaCH[BRANDS],
prevName;
if (brands) {
for (var i in brands) {
var brandName = brands[i].brand || brands[i],
brandVersion = brands[i].version;
if (
this.itemType == UA_BROWSER &&
!/not.a.brand/i.test(brandName) &&
(!prevName ||
(/chrom/i.test(prevName) && brandName != CHROMIUM))
) {
brandName = strMapper(brandName, {
Chrome: "Google Chrome",
Edge: "Microsoft Edge",
"Chrome WebView": "Android WebView",
"Chrome Headless": "HeadlessChrome",
});
this.set(NAME, brandName)
.set(VERSION, brandVersion)
.set(MAJOR, majorize(brandVersion));
prevName = brandName;
}
if (this.itemType == UA_ENGINE && brandName == CHROMIUM) {
this.set(VERSION, brandVersion);
}
}
}
break;
case UA_CPU:
var archName = uaCH[ARCHITECTURE];
if (archName) {
if (archName && uaCH[BITNESS] == "64") archName += "64";
rgxMapper.call(this.data, archName + ";", rgxMap);
}
break;
case UA_DEVICE:
if (uaCH[MOBILE]) {
this.set(TYPE, MOBILE);
}
if (uaCH[MODEL]) {
this.set(MODEL, uaCH[MODEL]);
if (!this.get(TYPE) || !this.get(VENDOR)) {
var reParse = {};
rgxMapper.call(reParse, "droid 9; " + uaCH[MODEL] + ")", rgxMap);
if (!this.get(TYPE) && !!reParse.type) {
this.set(TYPE, reParse.type);
}
if (!this.get(VENDOR) && !!reParse.vendor) {
this.set(VENDOR, reParse.vendor);
}
}
}
if (uaCH[FORMFACTORS]) {
var ff;
if (typeof uaCH[FORMFACTORS] !== "string") {
var idx = 0;
while (!ff && idx < uaCH[FORMFACTORS].length) {
ff = strMapper(uaCH[FORMFACTORS][idx++], formFactorsMap);
}
} else {
ff = strMapper(uaCH[FORMFACTORS], formFactorsMap);
}
this.set(TYPE, ff);
}
break;
case UA_OS:
var osName = uaCH[PLATFORM];
if (osName) {
var osVersion = uaCH[PLATFORMVER];
if (osName == WINDOWS)
osVersion = parseInt(majorize(osVersion), 10) >= 13 ? "11" : "10";
this.set(NAME, osName).set(VERSION, osVersion);
}
if (this.get(NAME) == WINDOWS && uaCH[MODEL] == "Xbox") {
this.set(NAME, "Xbox").set(VERSION, undefined);
}
break;
case UA_RESULT:
var data = this.data;
var parse = function (itemType) {
return data[itemType].getItem().setCH(uaCH).parseCH().get();
};
this.set(UA_BROWSER, parse(UA_BROWSER))
.set(UA_CPU, parse(UA_CPU))
.set(UA_DEVICE, parse(UA_DEVICE))
.set(UA_ENGINE, parse(UA_ENGINE))
.set(UA_OS, parse(UA_OS));
}
return this;
};
setProps.call(this, [
["itemType", itemType],
["ua", ua],
["uaCH", uaCH],
["rgxMap", rgxMap],
["data", createIData(this, itemType)],
]);
return this;
}
function UAParser(ua, extensions, headers) {
if (typeof ua === OBJ_TYPE) {
if (isExtensions(ua, true)) {
if (typeof extensions === OBJ_TYPE) {
headers = extensions; // case UAParser(extensions, headers)
}
extensions = ua; // case UAParser(extensions)
} else {
headers = ua; // case UAParser(headers)
extensions = undefined;
}
ua = undefined;
} else if (typeof ua === STR_TYPE && !isExtensions(extensions, true)) {
headers = extensions; // case UAParser(ua, headers)
extensions = undefined;
}
if (headers && typeof headers.append === FUNC_TYPE) {
var kv = {};
headers.forEach(function (v, k) {
kv[k] = v;
});
headers = kv;
}
if (!(this instanceof UAParser)) {
return new UAParser(ua, extensions, headers).getResult();
}
var userAgent =
typeof ua === STR_TYPE
? ua // Passed user-agent string
: headers && headers[USER_AGENT]
? headers[USER_AGENT] // User-Agent from passed headers
: NAVIGATOR && NAVIGATOR.userAgent
? NAVIGATOR.userAgent // navigator.userAgent
: EMPTY, // empty string
httpUACH = new UACHData(headers, true),
regexMap = extensions
? extend(defaultRegexes, extensions)
: defaultRegexes,
createItemFunc = function (itemType) {
if (itemType == UA_RESULT) {
return function () {
return new UAItem(itemType, userAgent, regexMap, httpUACH)
.set("ua", userAgent)
.set(UA_BROWSER, this.getBrowser())
.set(UA_CPU, this.getCPU())
.set(UA_DEVICE, this.getDevice())
.set(UA_ENGINE, this.getEngine())
.set(UA_OS, this.getOS())
.get();
};
} else {
return function () {
return new UAItem(itemType, userAgent, regexMap[itemType], httpUACH)
.parseUA()
.get();
};
}
};
setProps
.call(this, [
["getBrowser", createItemFunc(UA_BROWSER)],
["getCPU", createItemFunc(UA_CPU)],
["getDevice", createItemFunc(UA_DEVICE)],
["getEngine", createItemFunc(UA_ENGINE)],
["getOS", createItemFunc(UA_OS)],
["getResult", createItemFunc(UA_RESULT)],
[
"getUA",
function () {
return userAgent;
},
],
[
"setUA",
function (ua) {
if (isString(ua))
userAgent =
ua.length > UA_MAX_LENGTH ? trim(ua, UA_MAX_LENGTH) : ua;
return this;
},
],
])
.setUA(userAgent);
return this;
}
UAParser.VERSION = LIBVERSION;
UAParser.BROWSER = enumerize([NAME, VERSION, MAJOR, TYPE]);
UAParser.CPU = enumerize([ARCHITECTURE]);
UAParser.DEVICE = enumerize([
MODEL,
VENDOR,
TYPE,
CONSOLE,
MOBILE,
SMARTTV,
TABLET,
WEARABLE,
EMBEDDED,
]);
UAParser.ENGINE = UAParser.OS = enumerize([NAME, VERSION]);
if (typeof exports !== UNDEF_TYPE) {
if (typeof module !== UNDEF_TYPE && module.exports) {
exports = module.exports = UAParser;
}
exports.UAParser = UAParser;
} else {
if (typeof define === FUNC_TYPE && define.amd) {
define(function () {
return UAParser;
});
} else if (isWindow) {
window.UAParser = UAParser;
}
}
var $ = isWindow && (window.jQuery || window.Zepto);
if ($ && !$.ua) {
var parser = new UAParser();
$.ua = parser.getResult();
$.ua.get = function () {
return parser.getUA();
};
$.ua.set = function (ua) {
parser.setUA(ua);
var result = parser.getResult();
for (var prop in result) {
$.ua[prop] = result[prop];
}
};
}
})(typeof window === "object" ? window : this);
| 17,291 | 10,373 |
hyperswitch-web
|
src/Components/ClickToPayLearnMore.res
|
.res
|
open Utils
@react.component
let make = () => {
let (openModal, setOpenModal) = React.useState(_ => false)
let (cardBrand, setCardBrand) = React.useState(_ => "")
let logger = HyperLogger.make(~source=Elements(Payment))
let closeClickToPayModal = () => {
setOpenModal(_ => false)
messageParentWindow([("fullscreen", false->JSON.Encode.bool)])
}
React.useEffect0(() => {
ClickToPayHelpers.loadClickToPayScripts(logger)->ignore
let handle = (ev: Window.event) => {
let json = ev.data->safeParse
let dict = json->getDictFromJson
if dict->Dict.get("fullScreenIframeMounted")->Option.isSome {
let metadata = dict->getJsonObjectFromDict("metadata")->getDictFromJson
let cardBrands =
metadata
->Utils.getArray("cardBrands")
->Array.map(x => x->JSON.Decode.string->Option.getOr(""))
->Array.filter(x => x !== "")
->Array.joinWith(",")
if cardBrands === "" {
closeClickToPayModal()
}
setCardBrand(_ => cardBrands)
}
}
Window.addEventListener("message", handle)
messageParentWindow([("iframeMountedCallback", true->JSON.Encode.bool)])
Some(() => {Window.removeEventListener("message", handle)})
})
React.useEffect(() => {
let handleClickToPayLearnMore = _ => {
closeClickToPayModal()
}
Window.addEventListener("ok", handleClickToPayLearnMore)
Some(
() => {
Window.removeEventListener("ok", handleClickToPayLearnMore)
},
)
}, [])
<RenderIf condition={cardBrand !== ""}>
<div>
<Modal showClose=false openModal setOpenModal>
<ClickToPayHelpers.SrcLearnMore cardBrands=cardBrand />
</Modal>
</div>
</RenderIf>
}
| 425 | 10,374 |
hyperswitch-web
|
src/Components/BillingNamePaymentInput.res
|
.res
|
open RecoilAtoms
open PaymentType
open Utils
@react.component
let make = (~paymentType, ~customFieldName=None, ~requiredFields as optionalRequiredFields=?) => {
let {config, localeString} = Recoil.useRecoilValueFromAtom(configAtom)
let {fields} = Recoil.useRecoilValueFromAtom(optionAtom)
let loggerState = Recoil.useRecoilValueFromAtom(loggerAtom)
let (billingName, setBillingName) = Recoil.useLoggedRecoilState(
userBillingName,
"billingName",
loggerState,
)
let showDetails = getShowDetails(~billingDetails=fields.billingDetails, ~logger=loggerState)
let changeName = ev => {
let val: string = ReactEvent.Form.target(ev)["value"]
setBillingName(prev => {
value: val,
isValid: Some(val !== ""),
errorString: val !== "" ? "" : prev.errorString,
})
}
let onBlur = ev => {
let val: string = ReactEvent.Focus.target(ev)["value"]
setBillingName(prev => {
...prev,
isValid: Some(val !== ""),
})
}
let (placeholder, fieldName) = switch customFieldName {
| Some(val) => (val, val)
| None => (localeString.billingNamePlaceholder, localeString.billingNameLabel)
}
let nameRef = React.useRef(Nullable.null)
let submitCallback = React.useCallback((ev: Window.event) => {
let json = ev.data->safeParse
let confirm = json->getDictFromJson->ConfirmType.itemToObjMapper
if confirm.doSubmit {
if billingName.value == "" {
setBillingName(prev => {
...prev,
errorString: fieldName->localeString.nameEmptyText,
})
} else {
switch optionalRequiredFields {
| Some(requiredFields) =>
if !DynamicFieldsUtils.checkIfNameIsValid(requiredFields, BillingName, billingName) {
setBillingName(prev => {
...prev,
errorString: fieldName->localeString.completeNameEmptyText,
})
}
| None => ()
}
}
}
}, [billingName])
useSubmitPaymentData(submitCallback)
<RenderIf condition={showDetails.name == Auto}>
<PaymentField
fieldName
setValue=setBillingName
value=billingName
onChange=changeName
paymentType
onBlur
type_="text"
inputRef=nameRef
placeholder
className={config.appearance.innerLayout === Spaced ? "" : "!border-b-0"}
name=TestUtils.cardHolderNameInputTestId
/>
</RenderIf>
}
| 581 | 10,375 |
hyperswitch-web
|
src/Components/Or.res
|
.res
|
@react.component
let make = () => {
let {localeString} = Recoil.useRecoilValueFromAtom(RecoilAtoms.configAtom)
<div className="w-full w-max-[750px] relative flex flex-row my-4 " ariaHidden=true>
<div className="OrPayUsingLine relative top-[50%] h-[1px] bg-gray-400 w-full self-center" />
<div
className="OrPayUsingLabel relative min-w-fit px-5 text-sm text-gray-400 flex justify-center">
{React.string(localeString.orPayUsing)}
</div>
<div className="OrPayUsingLine relative top-[50%] h-[1px] bg-gray-400 w-full self-center" />
</div>
}
| 175 | 10,376 |
hyperswitch-web
|
src/Components/SaveDetailsCheckbox.res
|
.res
|
let saveDetailsCssStyle = (themeObj: CardThemeType.themeClass) => {
`.container {
display: flex;
cursor: pointer;
position: relative;
}
.container input {
position: absolute;
transform: scale(0);
}
.container input:checked ~ .checkmark {
transform: rotate(45deg);
height: 1em;
width: .4em;
border-color: ${themeObj.colorTextSecondary};
border-top-color: transparent;
border-left-color: transparent;
border-radius: 0;
margin-top: -2px;
margin-left: 8px;
}
.container .checkmark {
display: block;
width: 1em;
height: 1em;
border: 2px solid ${themeObj.colorTextSecondary};
border-radius: 2px;
transition: all .3s;
}
`
}
@react.component
let make = (~isChecked, ~setIsChecked) => {
let {themeObj} = Recoil.useRecoilValueFromAtom(RecoilAtoms.configAtom)
let showFields = Recoil.useRecoilValueFromAtom(RecoilAtoms.showCardFieldsAtom)
let {business, customMessageForCardTerms} = Recoil.useRecoilValueFromAtom(RecoilAtoms.optionAtom)
let css = saveDetailsCssStyle(themeObj)
let onChange = ev => {
let target = ev->ReactEvent.Form.target
let value = target["checked"]
setIsChecked(_ => value)
}
let {localeString} = Recoil.useRecoilValueFromAtom(RecoilAtoms.configAtom)
let (checkboxState, checkedState, checkBoxLabelState) = isChecked
? ("Checkbox--checked", "CheckboxInput--checked", "CheckboxLabel--checked")
: ("", "", "")
let saveCardCheckboxLabel = if showFields {
localeString.saveCardDetails
} else if customMessageForCardTerms->String.length > 0 {
customMessageForCardTerms
} else {
localeString.cardTerms(business.name)
}
<div
className={`Checkbox ${checkboxState} flex flex-row gap-2 items-center`}
tabIndex=0
onKeyDown={event => {
let key = JsxEvent.Keyboard.key(event)
let keyCode = JsxEvent.Keyboard.keyCode(event)
if key == "Enter" || keyCode == 13 {
setIsChecked(prev => !prev)
}
}}
role="checkbox"
ariaChecked={isChecked ? #"true" : #"false"}
ariaLabel={isChecked ? "Deselect to avoid saving card details" : "Select to save card details"}>
<style> {React.string(css)} </style>
<label className={`container CheckboxInput ${checkedState}`}>
<input tabIndex={-1} type_={`checkbox`} checked={isChecked} onChange />
<div className={`checkmark CheckboxInput ${checkedState}`} />
<div className={`CheckboxLabel ${checkBoxLabelState} ml-2 w-11/12 opacity-50 text-xs`}>
{React.string(saveCardCheckboxLabel)}
</div>
</label>
</div>
}
| 674 | 10,377 |
hyperswitch-web
|
src/Components/PoweredBy.res
|
.res
|
@react.component
let make = (~className="pt-4") => {
let {branding} = Recoil.useRecoilValueFromAtom(RecoilAtoms.optionAtom)
<RenderIf condition={branding == Auto}>
<div className={`text-xs text-center w-full flex justify-center ${className}`} ariaHidden=true>
<Icon size=18 width=130 name="powerd-by-hyper" />
</div>
</RenderIf>
}
| 101 | 10,378 |
hyperswitch-web
|
src/Components/VpaIdPaymentInput.res
|
.res
|
open RecoilAtoms
open Utils
@react.component
let make = (~paymentType) => {
let {localeString} = Recoil.useRecoilValueFromAtom(configAtom)
let loggerState = Recoil.useRecoilValueFromAtom(loggerAtom)
let (vpaId, setVpaId) = Recoil.useLoggedRecoilState(userVpaId, "vpaId", loggerState)
let vpaIdRef = React.useRef(Nullable.null)
let changeVpaId = ev => {
let val: string = ReactEvent.Form.target(ev)["value"]
setVpaId(prev => {
value: val,
isValid: val->isVpaIdValid,
errorString: val->isVpaIdValid->Option.getOr(false) ? "" : prev.errorString,
})
}
let onBlur = ev => {
let val = ReactEvent.Focus.target(ev)["value"]
let isValid = val->isVpaIdValid
let errorString = switch isValid {
| Some(val) => val ? "" : localeString.vpaIdInvalidText
| None => ""
}
setVpaId(prev => {
...prev,
isValid,
errorString,
})
}
let submitCallback = React.useCallback((ev: Window.event) => {
let json = ev.data->safeParse
let confirm = json->getDictFromJson->ConfirmType.itemToObjMapper
if confirm.doSubmit {
if vpaId.value == "" {
setVpaId(prev => {
...prev,
errorString: localeString.vpaIdEmptyText,
})
}
}
}, [vpaId])
useSubmitPaymentData(submitCallback)
<PaymentField
fieldName=localeString.vpaIdLabel
setValue={setVpaId}
value=vpaId
onChange=changeVpaId
onBlur
paymentType
type_="text"
name="vpaId"
inputRef=vpaIdRef
placeholder="Eg: johndoe@upi"
/>
}
| 452 | 10,379 |
hyperswitch-web
|
src/Components/CardElementShimmer.res
|
.res
|
@react.component
let make = () => {
<div className="shine w-full h-12 rounded">
<div className="flex flex-row my-auto">
<div className=" w-10 h-5 rounded-full m-3 bg-white bg-opacity-70 " />
<div className=" my-auto w-24 h-2 rounded m-3 bg-white bg-opacity-70 " />
</div>
</div>
}
| 98 | 10,380 |
hyperswitch-web
|
src/Components/ClickToPayAuthenticate.res
|
.res
|
open ClickToPayHelpers
open Promise
open Utils
@react.component
let make = (
~consumerIdentity,
~loggerState,
~savedMethods,
~setShowFields,
~setIsCTPAuthenticateNotYouClicked,
~setIsShowClickToPayNotYou,
~isClickToPayAuthenticateError,
~setIsClickToPayAuthenticateError,
~loadSavedCards,
~setPaymentToken,
~paymentTokenVal,
~cvcProps,
~paymentType,
) => {
let (clickToPayConfig, setClickToPayConfig) = Recoil.useRecoilState(RecoilAtoms.clickToPayConfig)
//TODO - To be discussed
let (_, setRequiredFieldsBody) = React.useState(_ => Dict.make())
let closeComponentIfSavedMethodsAreEmpty = () => {
if savedMethods->Array.length === 0 && loadSavedCards !== PaymentType.LoadingSavedCards {
setShowFields(_ => true)
}
}
<>
{switch clickToPayConfig.clickToPayCards {
| Some(cards) =>
if cards->Array.length == 0 {
if !isClickToPayAuthenticateError && clickToPayConfig.email !== "" {
let iframe = CommonHooks.createElement("iframe")
iframe.id = "mastercard-account-verification-iframe"
iframe.width = "100%"
iframe.height = "410px"
let element = ClickToPayHelpers.getElementById(
ClickToPayHelpers.myDocument,
"mastercard-account-verification",
)
try {
switch element->Nullable.toOption {
| Some(ele) =>
if ele.children->Array.length === 0 {
ele.appendChild(iframe)
switch iframe.contentWindow {
| Some(iframeContentWindow) => {
let authenticateConsumerIdentity = {
identityType: consumerIdentity.identityType,
identityValue: consumerIdentity.identityValue->String.replaceAll(" ", ""),
}
let authenticatePayload: ClickToPayHelpers.authenticateInputPayload = {
windowRef: iframeContentWindow,
consumerIdentity: authenticateConsumerIdentity,
}
ClickToPayHelpers.authenticate(authenticatePayload, loggerState)
->then(res => {
switch res {
| Ok(data) =>
let cards =
data
->getDictFromJson
->getJsonFromDict("cards", JSON.Encode.null)
->JSON.Decode.array
->Option.flatMap(arr => Some(
arr->Array.map(ClickToPayHelpers.clickToPayCardItemToObjMapper),
))
->Option.getOr([])
setClickToPayConfig(prev => {
...prev,
clickToPayCards: Some(cards),
})
ele.replaceChildren()
if cards->Array.length === 0 {
setIsClickToPayAuthenticateError(_ => true)
}
if cards->Array.length === 0 && savedMethods->Array.length === 0 {
setShowFields(_ => true)
}
resolve()
| Error(err) => {
let errException = err->formatException
loggerState.setLogError(
~value=`Error authenticating consumer identity - ${errException->JSON.stringify}`,
~eventName=CLICK_TO_PAY_FLOW,
)
let exceptionMessage =
errException
->getDictFromJson
->getJsonFromDict("message", JSON.Encode.null)
->JSON.Decode.string
->Option.getOr("")
let isNotYouClicked = exceptionMessage->String.includes("Not you clicked")
if isNotYouClicked {
setIsCTPAuthenticateNotYouClicked(_ => true)
setIsShowClickToPayNotYou(_ => true)
} else {
setIsClickToPayAuthenticateError(_ => true)
}
ele.replaceChildren()
resolve()
}
}
})
->catch(err => {
loggerState.setLogError(
~value=`Error authenticating consumer identity - ${err
->formatException
->JSON.stringify}`,
~eventName=CLICK_TO_PAY_FLOW,
)
closeComponentIfSavedMethodsAreEmpty()
resolve()
})
->ignore
}
| None => closeComponentIfSavedMethodsAreEmpty()
}
}
| None => ()
}
} catch {
| err => {
loggerState.setLogError(
~value=`Error - ${err->formatException->JSON.stringify}`,
~eventName=CLICK_TO_PAY_FLOW,
)
closeComponentIfSavedMethodsAreEmpty()
}
}
} else if isClickToPayAuthenticateError {
closeComponentIfSavedMethodsAreEmpty()
}
React.null
} else {
<>
<ClickToPayHelpers.SrcMark
cardBrands={clickToPayConfig.availableCardBrands->Array.joinWith(",")} height="32"
/>
<ClickToPayNotYou.ClickToPayNotYouText setIsShowClickToPayNotYou />
{cards
->Array.mapWithIndex((obj, i) => {
let customerMethod = obj->PaymentType.convertClickToPayCardToCustomerMethod
<SavedCardItem
key={"ctp_" ++ i->Int.toString}
setPaymentToken
isActive={paymentTokenVal == customerMethod.paymentToken}
paymentItem=customerMethod
brandIcon={customerMethod->CardUtils.getPaymentMethodBrand}
index=i
savedCardlength={cards->Array.length}
cvcProps
paymentType
setRequiredFieldsBody
/>
})
->React.array}
</>
}
| None =>
loggerState.setLogInfo(~value="Click to Pay cards not found", ~eventName=CLICK_TO_PAY_FLOW)
React.null
}}
</>
}
| 1,202 | 10,381 |
hyperswitch-web
|
src/Components/InfoElement.res
|
.res
|
@react.component
let make = () => {
let {themeObj, localeString} = Recoil.useRecoilValueFromAtom(RecoilAtoms.configAtom)
let selectedOption =
Recoil.useRecoilValueFromAtom(RecoilAtoms.selectedOptionAtom)->PaymentModeType.paymentMode
<div
className="InfoElement flex flex-row w-full pr-3 gap-3"
style={
color: themeObj.colorText,
fontSize: themeObj.fontSizeLg,
opacity: "60%",
fontWeight: themeObj.fontWeightLight,
}>
<div>
<Icon name="redirect" size=55 shouldMirrorIcon={localeString.localeDirection === "rtl"} />
</div>
<div className="self-center">
{switch selectedOption {
| ACHTransfer
| BacsTransfer
| SepaTransfer
| InstantTransfer
| Boleto =>
localeString.bankDetailsText
| _ => localeString.redirectText
}->React.string}
</div>
</div>
}
| 228 | 10,382 |
hyperswitch-web
|
src/Components/ErrorOccured.res
|
.res
|
@react.component
let make = () => {
<div className="flex justify-center font-bold text-lg text-red-600">
{React.string("Error occurred")}
</div>
}
| 42 | 10,383 |
hyperswitch-web
|
src/Components/SavedMethodItem.res
|
.res
|
@react.component
let make = (~brandIcon, ~paymentItem: PaymentType.customerMethods, ~handleDelete) => {
let {themeObj, localeString} = Recoil.useRecoilValueFromAtom(RecoilAtoms.configAtom)
let {hideExpiredPaymentMethods} = Recoil.useRecoilValueFromAtom(RecoilAtoms.optionAtom)
let isCard = paymentItem.paymentMethod === "card"
let expiryMonth = paymentItem.card.expiryMonth
let expiryYear = paymentItem.card.expiryYear
let expiryDate = Date.fromString(`${expiryYear}-${expiryMonth}`)
let currentDate = Date.make()
let pickerItemClass = "PickerItem--selected"
let isCardExpired = isCard && expiryDate < currentDate
let paymentMethodType = paymentItem.paymentMethodType->Option.getOr("debit")
<RenderIf condition={!hideExpiredPaymentMethods || !isCardExpired}>
<div
className={`PickerItem ${pickerItemClass} flex flex-row items-stretch`}
style={
minWidth: "150px",
width: "100%",
padding: "1rem 0 1rem 0",
borderBottom: `1px solid ${themeObj.borderColor}`,
borderTop: "none",
borderLeft: "none",
borderRight: "none",
borderRadius: "0px",
background: "transparent",
color: themeObj.colorTextSecondary,
boxShadow: "none",
opacity: {isCardExpired ? "0.7" : "1"},
}>
<div className="w-full">
<div>
<div className="flex flex-row justify-between items-center">
<div className="flex grow justify-between">
<div
className={`flex flex-row justify-center items-center`}
style={columnGap: themeObj.spacingUnit}>
<div className={`PickerItemIcon mx-3 flex items-center `}> brandIcon </div>
<div className="flex flex-col">
<div className="flex items-center gap-4">
{if isCard {
<div className="flex flex-col items-start">
<div> {React.string(paymentItem.card.nickname)} </div>
<div className={`PickerItemLabel flex flex-row gap-3 items-center`}>
<div className="tracking-widest"> {React.string(`****`)} </div>
<div> {React.string(paymentItem.card.last4Digits)} </div>
</div>
</div>
} else {
<div> {React.string(paymentMethodType->Utils.snakeToTitleCase)} </div>
}}
</div>
</div>
</div>
<RenderIf condition={isCard}>
<div
className={`flex flex-row items-center justify-end gap-3 -mt-1`}
style={fontSize: "14px", opacity: "0.5"}>
<div className="flex">
{React.string(
`${expiryMonth} / ${expiryYear->CardUtils.formatExpiryToTwoDigit}`,
)}
</div>
</div>
</RenderIf>
</div>
<Icon
size=18
name="delete"
style={color: themeObj.colorDanger}
className="cursor-pointer ml-4 mb-[6px]"
onClick={_ => handleDelete(paymentItem)->ignore}
/>
</div>
<div className="w-full">
<div className="flex flex-col items-start mx-8">
<RenderIf condition={isCardExpired}>
<div className="italic mt-3 ml-1" style={fontSize: "14px", opacity: "0.7"}>
{`*${localeString.cardExpiredText}`->React.string}
</div>
</RenderIf>
</div>
</div>
</div>
</div>
</div>
</RenderIf>
}
| 830 | 10,384 |
hyperswitch-web
|
src/Components/AccordionContainer.res
|
.res
|
open RecoilAtoms
module Loader = {
@react.component
let make = (~cardShimmerCount) => {
let paymentMethodList = Recoil.useRecoilValueFromAtom(paymentMethodList)
let {themeObj} = Recoil.useRecoilValueFromAtom(configAtom)
let {layout} = Recoil.useRecoilValueFromAtom(optionAtom)
let layoutClass = CardUtils.getLayoutClass(layout)
open PaymentType
open PaymentElementShimmer
switch paymentMethodList {
| SemiLoaded =>
Array.make(~length=cardShimmerCount - 1, "")
->Array.mapWithIndex((_, i) => {
let borderStyle = layoutClass.spacedAccordionItems
? themeObj.borderRadius
: i == cardShimmerCount - 2
? `0px 0px ${themeObj.borderRadius} ${themeObj.borderRadius}`
: ""
<div
className={`AccordionItem flex flex-row gap-3 animate-pulse cursor-default place-items-center`}
key={i->Int.toString}
style={
minWidth: "80px",
minHeight: "60px",
overflowWrap: "hidden",
borderRadius: {borderStyle},
border: `1px solid ${themeObj.borderColor}`,
borderBottomStyle: {
(i == cardShimmerCount - 2 && !layoutClass.spacedAccordionItems) ||
layoutClass.spacedAccordionItems
? "solid"
: "hidden"
},
borderTopStyle: {i == 0 && !layoutClass.spacedAccordionItems ? "hidden" : "solid"},
width: "100%",
marginBottom: layoutClass.spacedAccordionItems ? themeObj.spacingAccordionItem : "",
cursor: "pointer",
}>
<Shimmer classname="opacity-50 h-5 w-[10%] rounded-full">
<div
className="w-full h-full animate-pulse"
style={backgroundColor: themeObj.colorPrimary, opacity: "10%"}
/>
</Shimmer>
<Shimmer classname="opacity-50 h-2 w-[30%] rounded-full">
<div
className="w-full h-full animate-pulse"
style={backgroundColor: themeObj.colorPrimary, opacity: "10%"}
/>
</Shimmer>
</div>
})
->React.array
| _ => React.null
}
}
}
@react.component
let make = (~paymentOptions: array<string>, ~checkoutEle: React.element, ~cardProps) => {
let {themeObj} = Recoil.useRecoilValueFromAtom(configAtom)
let paymentMethodList = Recoil.useRecoilValueFromAtom(paymentMethodList)
let {layout} = Recoil.useRecoilValueFromAtom(optionAtom)
let layoutClass = CardUtils.getLayoutClass(layout)
let (showMore, setShowMore) = React.useState(_ => false)
let (selectedOption, setSelectedOption) = Recoil.useRecoilState(selectedOptionAtom)
let paymentMethodListValue = Recoil.useRecoilValueFromAtom(PaymentUtils.paymentMethodListValue)
let (_, _, _, _, _, _, _, _, _, _, _, cardBrand) = cardProps
PaymentUtils.useEmitPaymentMethodInfo(
~paymentMethodName=selectedOption,
~paymentMethods=paymentMethodListValue.payment_methods,
~cardBrand,
)
let cardOptionDetails =
paymentOptions
->PaymentMethodsRecord.getPaymentDetails
->Array.slice(~start=0, ~end=layoutClass.maxAccordionItems)
let dropDownOptionsDetails =
paymentOptions
->PaymentMethodsRecord.getPaymentDetails
->Array.sliceToEnd(~start=layoutClass.maxAccordionItems)
let getBorderRadiusStyleForCardOptionDetails = index => {
if (
!showMore &&
!layoutClass.spacedAccordionItems &&
index == 0 &&
paymentMethodList == SemiLoaded &&
cardOptionDetails->Array.length == 1
) {
`${themeObj.borderRadius} ${themeObj.borderRadius} 0px 0px`
} else if (
!showMore &&
!layoutClass.spacedAccordionItems &&
index == 0 &&
cardOptionDetails->Array.length == 1
) {
themeObj.borderRadius
} else if (
!showMore && !layoutClass.spacedAccordionItems && index == cardOptionDetails->Array.length - 1
) {
`0px 0px ${themeObj.borderRadius} ${themeObj.borderRadius}`
} else if !layoutClass.spacedAccordionItems && index == 0 {
`${themeObj.borderRadius} ${themeObj.borderRadius} 0px 0px`
} else if layoutClass.spacedAccordionItems {
themeObj.borderRadius
} else {
"0px"
}
}
let getBorderRadiusStyleForDropDownOptionDetails = index => {
if !layoutClass.spacedAccordionItems && index == dropDownOptionsDetails->Array.length - 1 {
`0px 0px ${themeObj.borderRadius} ${themeObj.borderRadius}`
} else if layoutClass.spacedAccordionItems {
themeObj.borderRadius
} else {
"0px"
}
}
React.useEffect0(() => {
layoutClass.defaultCollapsed ? setSelectedOption(_ => "") : ()
None
})
<div className="w-full">
<div
className="AccordionContainer flex flex-col overflow-auto no-scrollbar"
style={
marginTop: themeObj.spacingAccordionItem,
width: "-webkit-fill-available",
marginBottom: themeObj.spacingAccordionItem,
}>
{cardOptionDetails
->Array.mapWithIndex((payOption, i) => {
let isActive = payOption.paymentMethodName == selectedOption
let borderRadiusStyle = getBorderRadiusStyleForCardOptionDetails(i)
<Accordion
key={i->Int.toString}
paymentOption=payOption
isActive
checkoutEle
borderRadiusStyle={borderRadiusStyle}
borderBottom={(!showMore &&
i == cardOptionDetails->Array.length - 1 &&
!layoutClass.spacedAccordionItems) || layoutClass.spacedAccordionItems}
/>
})
->React.array}
<Loader cardShimmerCount=layoutClass.maxAccordionItems />
<RenderIf condition={showMore}>
{dropDownOptionsDetails
->Array.mapWithIndex((payOption, i) => {
let isActive = payOption.paymentMethodName == selectedOption
let borderRadiusStyle = getBorderRadiusStyleForDropDownOptionDetails(i)
<Accordion
key={i->Int.toString}
paymentOption=payOption
isActive
checkoutEle
borderRadiusStyle={borderRadiusStyle}
borderBottom={(i == dropDownOptionsDetails->Array.length - 1 &&
!layoutClass.spacedAccordionItems) || layoutClass.spacedAccordionItems}
/>
})
->React.array}
</RenderIf>
</div>
<RenderIf condition={!showMore && dropDownOptionsDetails->Array.length > 0}>
<button
className="AccordionMore flex overflow-auto no-scrollbar"
onClick={_ => setShowMore(_ => !showMore)}
style={
borderRadius: themeObj.borderRadius,
marginTop: themeObj.spacingUnit,
columnGap: themeObj.spacingUnit,
minHeight: "60px",
minWidth: "150px",
width: "100%",
padding: "20px",
cursor: "pointer",
}>
<div className="flex flex-row" style={columnGap: themeObj.spacingUnit}>
<div className="m-2">
<Icon size=10 name="arrow-down" />
</div>
<div className="AccordionItemLabel"> {React.string("More")} </div>
</div>
</button>
</RenderIf>
</div>
}
| 1,691 | 10,385 |
hyperswitch-web
|
src/Components/Loader.res
|
.res
|
@react.component
let make = (~branding="auto", ~showText=true) => {
let arr = ["hyperswitch-triangle", "hyperswitch-square", "hyperswitch-circle"]
<div className="flex flex-col gap-10 justify-center items-center">
<div className="flex flex-row gap-10">
<RenderIf condition={branding === "auto"}>
{arr
->Array.mapWithIndex((item, i) => {
<Icon
size=52
style={
animation: "slowShow 1.5s ease-in-out infinite",
animationDelay: {((i + 1) * 180)->Int.toString ++ "ms"},
}
name=item
key={i->Int.toString}
/>
})
->React.array}
</RenderIf>
<RenderIf condition={branding === "never"}>
<div
className="inline-block h-8 w-8 animate-spin rounded-full border-4 border-solid border-[#0069FD] border-r-transparent align-[-0.125em] motion-reduce:animate-[spin_1.5s_linear_infinite]"
role="status">
<span
className="!absolute !-m-px !h-px !w-px !overflow-hidden !whitespace-nowrap !border-0 !p-0 ![clip:rect(0,0,0,0)]">
{"Loading..."->React.string}
</span>
</div>
</RenderIf>
</div>
<RenderIf condition={showText}>
<div className="flex flex-col gap-5">
<div className="font-semibold text-sm text-gray-200 self-center ">
{React.string("We are processing your payment...")}
</div>
<div className="font-medium text-xs text-gray-400 self-center text-center w-3/4 ">
{React.string(
"You have been redirected to new tab to complete your payments. Status will be updated automatically",
)}
</div>
</div>
</RenderIf>
</div>
}
| 463 | 10,386 |
hyperswitch-web
|
src/Components/Surcharge.res
|
.res
|
@react.component
let make = (
~paymentMethod,
~paymentMethodType,
~cardBrand=CardUtils.NOTFOUND,
~isForWallets=false,
) => {
let paymentMethodListValue = Recoil.useRecoilValueFromAtom(PaymentUtils.paymentMethodListValue)
let getPaymentMethodTypes = paymentMethodType => {
PaymentMethodsRecord.getPaymentMethodTypeFromList(
~paymentMethodListValue,
~paymentMethod,
~paymentMethodType=PaymentUtils.getPaymentMethodName(
~paymentMethodType=paymentMethod,
~paymentMethodName=paymentMethodType,
),
)->Option.getOr(PaymentMethodsRecord.defaultPaymentMethodType)
}
let paymentMethodTypes = paymentMethodType->getPaymentMethodTypes
let getOneClickWalletsMessage = SurchargeUtils.useOneClickWalletsMessageGetter(
~paymentMethodListValue,
)
let getSurchargeUtilsMessage = SurchargeUtils.useMessageGetter()
let getSurchargeMessage = () => {
if isForWallets {
getOneClickWalletsMessage()
} else {
switch paymentMethodTypes.surcharge_details {
| Some(surchargeDetails) =>
getSurchargeUtilsMessage(~paymentMethod, ~surchargeDetails, ~paymentMethodListValue)
| None =>
if paymentMethod === "card" {
let creditPaymentMethodTypes = getPaymentMethodTypes("credit")
let debitCardNetwork = PaymentMethodsRecord.getCardNetwork(
~paymentMethodType=paymentMethodTypes,
~cardBrand,
)
let creditCardNetwork = PaymentMethodsRecord.getCardNetwork(
~paymentMethodType=creditPaymentMethodTypes,
~cardBrand,
)
switch (debitCardNetwork.surcharge_details, creditCardNetwork.surcharge_details) {
| (Some(debitSurchargeDetails), Some(creditSurchargeDetails)) =>
let creditCardSurcharge = creditSurchargeDetails.displayTotalSurchargeAmount
let debitCardSurcharge = debitSurchargeDetails.displayTotalSurchargeAmount
if creditCardSurcharge >= debitCardSurcharge {
getSurchargeUtilsMessage(
~paymentMethod,
~surchargeDetails={creditSurchargeDetails},
~paymentMethodListValue,
)
} else {
getSurchargeUtilsMessage(
~paymentMethod,
~surchargeDetails={debitSurchargeDetails},
~paymentMethodListValue,
)
}
| (None, Some(surchargeDetails))
| (Some(surchargeDetails), None) =>
getSurchargeUtilsMessage(~paymentMethod, ~surchargeDetails, ~paymentMethodListValue)
| (None, None) => None
}
} else {
None
}
}
}
}
switch getSurchargeMessage() {
| Some(surchargeMessage) =>
<div className="flex items-baseline text-xs mt-2">
<Icon name="asterisk" size=8 className="text-red-600 mr-1" />
<div className="text-left text-gray-400"> {surchargeMessage} </div>
</div>
| None => React.null
}
}
| 679 | 10,387 |
hyperswitch-web
|
src/Components/PhoneNumberPaymentInput.res
|
.res
|
@react.component
let make = () => {
open RecoilAtoms
open PaymentType
open Utils
let phoneRef = React.useRef(Nullable.null)
let {fields} = Recoil.useRecoilValueFromAtom(optionAtom)
let loggerState = Recoil.useRecoilValueFromAtom(loggerAtom)
let showDetails = getShowDetails(~billingDetails=fields.billingDetails, ~logger=loggerState)
let (phone, setPhone) = Recoil.useLoggedRecoilState(userPhoneNumber, "phone", loggerState)
let clientCountry = getClientCountry(CardUtils.dateTimeFormat().resolvedOptions().timeZone)
let currentCountryCode = Utils.getCountryCode(clientCountry.countryName)
let (displayValue, setDisplayValue) = React.useState(_ => "")
let countryAndCodeCodeList =
phoneNumberJson
->JSON.Decode.object
->Option.getOr(Dict.make())
->getArray("countries")
let phoneNumberCodeOptions: array<
DropdownField.optionType,
> = countryAndCodeCodeList->Array.reduce([], (acc, countryObj) => {
let countryObjDict = countryObj->getDictFromJson
let countryFlag = countryObjDict->getString("country_flag", "")
let phoneNumberCode = countryObjDict->getString("phone_number_code", "")
let countryName = countryObjDict->getString("country_name", "")
let phoneNumberOptionsValue: DropdownField.optionType = {
label: `${countryFlag} ${countryName} ${phoneNumberCode}`,
displayValue: `${countryFlag} ${phoneNumberCode}`,
value: `${countryFlag}#${phoneNumberCode}`,
}
acc->Array.push(phoneNumberOptionsValue)
acc
})
let defaultCountryCodeFilteredValue =
countryAndCodeCodeList
->Array.filter(countryObj => {
countryObj->getDictFromJson->getString("country_code", "") === currentCountryCode.isoAlpha2
})
->Array.get(0)
->Option.getOr(
{
"phone_number_code": "",
}->Identity.anyTypeToJson,
)
->getDictFromJson
->getString("phone_number_code", "")
let (valueDropDown, setValueDropDown) = React.useState(_ => defaultCountryCodeFilteredValue)
let getCountryCodeSplitValue = val => val->String.split("#")->Array.get(1)->Option.getOr("")
let changePhone = ev => {
let val: string = ReactEvent.Form.target(ev)["value"]->String.replaceRegExp(%re("/\D|\s/g"), "")
setPhone(prev => {
...prev,
countryCode: valueDropDown->getCountryCodeSplitValue,
value: val,
})
}
React.useEffect(() => {
setPhone(prev => {
...prev,
countryCode: valueDropDown->getCountryCodeSplitValue,
})
None
}, [valueDropDown])
React.useEffect(() => {
let findDisplayValue =
phoneNumberCodeOptions
->Array.find(ele => ele.value === valueDropDown)
->Option.getOr(DropdownField.defaultValue)
setDisplayValue(_ =>
findDisplayValue.displayValue->Option.getOr(
findDisplayValue.label->Option.getOr(findDisplayValue.value),
)
)
None
}, [phoneNumberCodeOptions])
<RenderIf condition={showDetails.phone == Auto}>
<PaymentField
fieldName="Phone Number"
value=phone
onChange=changePhone
paymentType=Payment
type_="tel"
name="phone"
inputRef=phoneRef
placeholder="000 000 000"
maxLength=14
dropDownOptions=phoneNumberCodeOptions
valueDropDown
setValueDropDown
displayValue
setDisplayValue
/>
</RenderIf>
}
| 808 | 10,388 |
hyperswitch-web
|
src/Components/FullScreenDivDriver.res
|
.res
|
@react.component
let make = () => {
React.useEffect0(() => {
Utils.messageParentWindow([("driverMounted", true->JSON.Encode.bool)])
None
})
<div />
}
| 44 | 10,389 |
hyperswitch-web
|
src/Components/Block.res
|
.res
|
@react.component
let make = (~topElement=?, ~bottomElement=?, ~padding="p-5", ~className="") => {
let {themeObj} = Recoil.useRecoilValueFromAtom(RecoilAtoms.configAtom)
let topBlock = switch topElement {
| Some(ele) => ele
| None => React.null
}
let actionBlock = switch bottomElement {
| Some(ele) => ele
| None => React.null
}
let divider = switch (topElement, bottomElement) {
| (Some(_), Some(_)) =>
<div
className={"BlockDivider"}
style={
marginTop: themeObj.spacingUnit,
marginBottom: themeObj.spacingUnit,
}
/>
| (_, _) => React.null
}
<div
className={`Block flex flex-col ${padding} ${className}`}
style={lineHeight: themeObj.fontLineHeight}>
<div className="BlockTop"> {topBlock} </div>
{divider}
<div className="BlockAction"> {actionBlock} </div>
</div>
}
| 236 | 10,390 |
hyperswitch-web
|
src/Components/PortalCapture.res
|
.res
|
@react.component
let make = React.memo((~name: string) => {
let (_, setPortalNodes) = Recoil.useRecoilState(RecoilAtoms.portalNodes)
let setDiv = React.useCallback((elem: Nullable.t<Dom.element>) => {
setPortalNodes(
prevDict => {
let clonedDict =
prevDict
->Dict.toArray
->Array.filter(
entry => {
let (key, _val) = entry
key !== name
},
)
->Dict.fromArray
switch elem->Nullable.toOption {
| Some(elem) => Dict.set(clonedDict, name, elem)
| None => ()
}
clonedDict
},
)
}, (setPortalNodes, name))
<div id="sss" ref={ReactDOM.Ref.callbackDomRef(setDiv)} />
})
| 183 | 10,391 |
hyperswitch-web
|
src/Components/PaymentElementShimmer.res
|
.res
|
module Shimmer = {
@react.component
let make = (~children, ~classname="") => {
<div
className={`relative
${classname}
before:absolute before:inset-0
before:-translate-x-full
before:animate-[shimmer_1s_infinite]
before:bg-gradient-to-r
before:px-1
before: rounded
before:from-transparent before:via-slate-200 before:to-transparent overflow-hidden w-full`}>
children
</div>
}
}
module SavedPaymentShimmer = {
@react.component
let make = () => {
<Shimmer>
<div className="animate-pulse w-full h-12 rounded bg-slate-200">
<div className="flex flex-row my-auto">
<div className="w-10 h-5 rounded-full m-3 bg-white bg-opacity-70" />
<div className="my-auto w-24 h-2 rounded m-3 bg-white bg-opacity-70" />
</div>
</div>
</Shimmer>
}
}
module SavedPaymentCardShimmer = {
@react.component
let make = () => {
let {themeObj} = Recoil.useRecoilValueFromAtom(RecoilAtoms.configAtom)
<div
className="Label flex flex-row gap-3 items-end cursor-pointer"
style={
fontSize: "14px",
color: themeObj.colorPrimary,
fontWeight: "400",
marginTop: "25px",
}>
<SavedPaymentShimmer />
</div>
}
}
@react.component
let make = () => {
<div className="flex flex-col gap-4">
<Shimmer>
<div className="animate-pulse w-full h-12 rounded bg-slate-200 ">
<div className="flex flex-row my-auto">
<div className=" w-10 h-5 rounded-full m-3 bg-white bg-opacity-70 " />
<div className=" my-auto w-24 h-2 rounded m-3 bg-white bg-opacity-70 " />
</div>
</div>
</Shimmer>
<Shimmer>
<div className="animate-pulse w-full h-12 rounded bg-slate-200 ">
<div className="flex flex-row my-auto">
<div className=" w-10 h-5 rounded-full m-3 bg-white bg-opacity-70 " />
<div className=" my-auto w-24 h-2 rounded m-3 bg-white bg-opacity-70 " />
</div>
</div>
</Shimmer>
<div className="flex flex-row gap-4 w-full">
<Shimmer>
<div className="animate-pulse w-auto h-12 rounded bg-slate-200">
<div className="flex flex-row my-auto">
<div className=" w-10 h-5 rounded-full m-3 bg-white bg-opacity-70 " />
<div className=" my-auto w-24 h-2 rounded m-3 bg-white bg-opacity-70 " />
</div>
</div>
</Shimmer>
<Shimmer>
<div className="animate-pulse w-auto h-12 rounded bg-slate-200">
<div className="flex flex-row my-auto">
<div className=" w-10 h-5 rounded-full m-3 bg-white bg-opacity-70 " />
<div className=" my-auto w-24 h-2 rounded m-3 bg-white bg-opacity-70 " />
</div>
</div>
</Shimmer>
</div>
</div>
}
| 830 | 10,392 |
hyperswitch-web
|
src/Components/FullScreenPortal.res
|
.res
|
open Utils
@val @scope(("window", "parent", "frames", `"fullscreen"`, "document"))
external getElementById: string => Dom.element = "getElementById"
@react.component
let make = (~children) => {
let (fullScreenIframeNode, setFullScreenIframeNode) = React.useState(() => Nullable.null)
React.useEffectOnEveryRender(() => {
let handle = (ev: Window.event) => {
try {
let json = ev.data->safeParse
let dict = json->getDictFromJson
if dict->Dict.get("fullScreenIframeMounted")->Option.isSome {
if dict->getBool("fullScreenIframeMounted", false) {
setFullScreenIframeNode(_ =>
switch Window.windowParent->Window.fullscreen {
| Some(doc) => doc->Window.document->Window.getElementById("fullscreen")
| None => Nullable.null
}
)
}
}
} catch {
| _err => ()
}
}
Window.addEventListener("message", handle)
Some(() => {Window.removeEventListener("message", handle)})
})
switch fullScreenIframeNode->Nullable.toOption {
| Some(domNode) => ReactDOM.createPortal(children, domNode)
| None => React.null
}
}
| 272 | 10,393 |
hyperswitch-web
|
src/Components/Terms.res
|
.res
|
@react.component
let make = (~mode: PaymentModeType.payment, ~styles: JsxDOMStyle.t={}) => {
open RecoilAtoms
let {localeString, themeObj} = Recoil.useRecoilValueFromAtom(configAtom)
let {customMessageForCardTerms, business, terms} = Recoil.useRecoilValueFromAtom(optionAtom)
let cardTermsValue =
customMessageForCardTerms->String.length > 0
? customMessageForCardTerms
: localeString.cardTerms(business.name)
let terms = switch mode {
| ACHBankDebit => (localeString.achBankDebitTerms(business.name), terms.usBankAccount)
| SepaBankDebit => (localeString.sepaDebitTerms(business.name), terms.sepaDebit)
| BecsBankDebit => (localeString.becsDebitTerms, terms.auBecsDebit)
| Card => (cardTermsValue, terms.card)
| _ => ("", Auto)
}
let (termsText, showTerm) = terms
<RenderIf condition={showTerm == Auto || showTerm == Always}>
<div
className="TermsTextLabel opacity-50 text-xs mb-2 text-left"
style={...styles, color: themeObj.colorText}>
{React.string(termsText)}
</div>
</RenderIf>
}
| 301 | 10,394 |
hyperswitch-web
|
src/Components/SavedMethods.res
|
.res
|
@react.component
let make = (
~paymentToken: RecoilAtomTypes.paymentToken,
~setPaymentToken,
~savedMethods: array<PaymentType.customerMethods>,
~loadSavedCards: PaymentType.savedCardsLoadState,
~cvcProps,
~paymentType,
~sessions,
~isClickToPayAuthenticateError,
~setIsClickToPayAuthenticateError,
) => {
open CardUtils
open Utils
open UtilityHooks
open Promise
open ClickToPayHelpers
let clickToPayConfig = Recoil.useRecoilValueFromAtom(RecoilAtoms.clickToPayConfig)
let customerMethods =
clickToPayConfig.clickToPayCards
->Option.getOr([])
->Array.map(obj => obj->PaymentType.convertClickToPayCardToCustomerMethod)
let (isCTPAuthenticateNotYouClicked, setIsCTPAuthenticateNotYouClicked) = React.useState(_ =>
false
)
let (isShowClickToPayNotYou, setIsShowClickToPayNotYou) = React.useState(_ => false)
let (consumerIdentity, setConsumerIdentity) = React.useState(_ => {
identityType: EMAIL_ADDRESS,
identityValue: "",
})
let {themeObj, localeString} = Recoil.useRecoilValueFromAtom(RecoilAtoms.configAtom)
let (showFields, setShowFields) = Recoil.useRecoilState(RecoilAtoms.showCardFieldsAtom)
let areRequiredFieldsValid = Recoil.useRecoilValueFromAtom(RecoilAtoms.areRequiredFieldsValid)
let isManualRetryEnabled = Recoil.useRecoilValueFromAtom(RecoilAtoms.isManualRetryEnabled)
let (requiredFieldsBody, setRequiredFieldsBody) = React.useState(_ => Dict.make())
let loggerState = Recoil.useRecoilValueFromAtom(RecoilAtoms.loggerAtom)
let setUserError = message => {
postFailedSubmitResponse(~errortype="validation_error", ~message)
loggerState.setLogError(~value=message, ~eventName=INVALID_FORMAT)
}
let (isSaveCardsChecked, setIsSaveCardsChecked) = React.useState(_ => false)
let {displaySavedPaymentMethodsCheckbox, readOnly} = Recoil.useRecoilValueFromAtom(
RecoilAtoms.optionAtom,
)
let isGuestCustomer = useIsGuestCustomer()
let {iframeId} = Recoil.useRecoilValueFromAtom(RecoilAtoms.keys)
let url = RescriptReactRouter.useUrl()
let componentName = CardUtils.getQueryParamsDictforKey(url.search, "componentName")
let dict = sessions->Utils.getDictFromJson
let sessionObj = React.useMemo(() => SessionsType.itemToObjMapper(dict, Others), [dict])
let gPayToken = SessionsType.getPaymentSessionObj(sessionObj.sessionsToken, Gpay)
let applePaySessionObj = SessionsType.itemToObjMapper(dict, ApplePayObject)
let applePayToken = SessionsType.getPaymentSessionObj(applePaySessionObj.sessionsToken, ApplePay)
let samsungPaySessionObj = SessionsType.itemToObjMapper(dict, SamsungPayObject)
let samsungPayToken = SessionsType.getPaymentSessionObj(
samsungPaySessionObj.sessionsToken,
SamsungPay,
)
let intent = PaymentHelpers.usePaymentIntent(Some(loggerState), Card)
let savedCardlength = savedMethods->Array.length
let paymentMethodListValue = Recoil.useRecoilValueFromAtom(PaymentUtils.paymentMethodListValue)
let {paymentToken: paymentTokenVal, customerId} = paymentToken
React.useEffect(() => {
if clickToPayConfig.email !== "" && consumerIdentity.identityValue === "" {
setConsumerIdentity(_ => {
identityType: EMAIL_ADDRESS,
identityValue: clickToPayConfig.email,
})
}
None
}, [clickToPayConfig.email])
let _closeComponentIfSavedMethodsAreEmpty = () => {
if savedCardlength === 0 && loadSavedCards !== PaymentType.LoadingSavedCards {
setShowFields(_ => true)
}
}
let bottomElement = {
<div
className="PickerItemContainer" tabIndex={0} role="region" ariaLabel="Saved payment methods">
{savedMethods
->Array.mapWithIndex((obj, i) =>
<SavedCardItem
key={i->Int.toString}
setPaymentToken
isActive={paymentTokenVal == obj.paymentToken}
paymentItem=obj
brandIcon={obj->getPaymentMethodBrand}
index=i
savedCardlength
cvcProps
paymentType
setRequiredFieldsBody
/>
)
->React.array}
<RenderIf
condition={clickToPayConfig.clickToPayCards->Option.getOr([])->Array.length == 0 &&
!isClickToPayAuthenticateError &&
clickToPayConfig.email !== ""}>
<ClickToPayHelpers.SrcMark
cardBrands={clickToPayConfig.availableCardBrands->Array.joinWith(",")} height="32"
/>
</RenderIf>
<div id="mastercard-account-verification" />
{if isShowClickToPayNotYou {
<ClickToPayNotYou
setIsShowClickToPayNotYou isCTPAuthenticateNotYouClicked setConsumerIdentity
/>
} else {
<ClickToPayAuthenticate
consumerIdentity
loggerState
savedMethods
setShowFields
setIsCTPAuthenticateNotYouClicked
setIsShowClickToPayNotYou
isClickToPayAuthenticateError
setIsClickToPayAuthenticateError
loadSavedCards
setPaymentToken
paymentTokenVal
cvcProps
paymentType
/>
}}
</div>
}
let (isCVCValid, _, cvcNumber, _, _, _, _, _, _, setCvcError) = cvcProps
let complete = switch isCVCValid {
| Some(val) => paymentTokenVal !== "" && val
| _ => false
}
let empty = cvcNumber == ""
let customerMethod = React.useMemo(_ =>
savedMethods
->Array.concat(customerMethods)
->Array.filter(savedMethod => savedMethod.paymentToken === paymentTokenVal)
->Array.get(0)
->Option.getOr(PaymentType.defaultCustomerMethods)
, [paymentTokenVal])
let isUnknownPaymentMethod = customerMethod.paymentMethod === ""
let isCardPaymentMethod = customerMethod.paymentMethod === "card"
let isCardPaymentMethodValid = !customerMethod.requiresCvv || (complete && !empty)
let complete =
areRequiredFieldsValid &&
!isUnknownPaymentMethod &&
(!isCardPaymentMethod || isCardPaymentMethodValid)
let paymentMethodType =
customerMethod.paymentMethodType->Option.getOr(customerMethod.paymentMethod)
useHandlePostMessages(~complete, ~empty, ~paymentType=paymentMethodType, ~savedMethod=true)
GooglePayHelpers.useHandleGooglePayResponse(~connectors=[], ~intent, ~isSavedMethodsFlow=true)
ApplePayHelpers.useHandleApplePayResponse(~connectors=[], ~intent, ~isSavedMethodsFlow=true)
SamsungPayHelpers.useHandleSamsungPayResponse(~intent, ~isSavedMethodsFlow=true)
let submitCallback = React.useCallback((ev: Window.event) => {
let json = ev.data->safeParse
let confirm = json->getDictFromJson->ConfirmType.itemToObjMapper
let isCustomerAcceptanceRequired = customerMethod.recurringEnabled->not || isSaveCardsChecked
let savedPaymentMethodBody = switch customerMethod.paymentMethod {
| "card" =>
PaymentBody.savedCardBody(
~paymentToken=paymentTokenVal,
~customerId,
~cvcNumber,
~requiresCvv=customerMethod.requiresCvv,
~isCustomerAcceptanceRequired,
)
| _ => {
let paymentMethodType = switch customerMethod.paymentMethodType {
| Some("")
| None => JSON.Encode.null
| Some(paymentMethodType) => paymentMethodType->JSON.Encode.string
}
PaymentBody.savedPaymentMethodBody(
~paymentToken=paymentTokenVal,
~customerId,
~paymentMethod=customerMethod.paymentMethod,
~paymentMethodType,
~isCustomerAcceptanceRequired,
)
}
}
if confirm.doSubmit {
if customerMethod.card.isClickToPayCard {
ClickToPayHelpers.handleProceedToPay(
~srcDigitalCardId=customerMethod.paymentToken,
~logger=loggerState,
)
->then(resp => {
let dict = resp.payload->Utils.getDictFromJson
let headers = dict->Utils.getDictFromDict("headers")
let merchantTransactionId = headers->Utils.getString("merchant-transaction-id", "")
let xSrcFlowId = headers->Utils.getString("x-src-cx-flow-id", "")
let correlationId =
dict
->Utils.getDictFromDict("checkoutResponseData")
->Utils.getString("srcCorrelationId", "")
let clickToPayBody = PaymentBody.clickToPayBody(
~merchantTransactionId,
~correlationId,
~xSrcFlowId,
)
intent(
~bodyArr=clickToPayBody->mergeAndFlattenToTuples(requiredFieldsBody),
~confirmParam=confirm.confirmParams,
~handleUserError=false,
~manualRetry=isManualRetryEnabled,
)
resolve(resp)
})
->catch(_ =>
resolve({
status: ERROR,
payload: JSON.Encode.null,
})
)
->ignore
} else if (
areRequiredFieldsValid &&
!isUnknownPaymentMethod &&
(!isCardPaymentMethod || isCardPaymentMethodValid) &&
confirm.confirmTimestamp >= confirm.readyTimestamp
) {
switch customerMethod.paymentMethodType {
| Some("google_pay") =>
switch gPayToken {
| OtherTokenOptional(optToken) =>
GooglePayHelpers.handleGooglePayClicked(
~sessionObj=optToken,
~componentName,
~iframeId,
~readOnly,
)
| _ =>
// TODO - To be replaced with proper error message
intent(
~bodyArr=savedPaymentMethodBody->mergeAndFlattenToTuples(requiredFieldsBody),
~confirmParam=confirm.confirmParams,
~handleUserError=false,
~manualRetry=isManualRetryEnabled,
)
}
| Some("apple_pay") =>
switch applePayToken {
| ApplePayTokenOptional(optToken) =>
ApplePayHelpers.handleApplePayButtonClicked(
~sessionObj=optToken,
~componentName,
~paymentMethodListValue,
)
| _ =>
// TODO - To be replaced with proper error message
intent(
~bodyArr=savedPaymentMethodBody->mergeAndFlattenToTuples(requiredFieldsBody),
~confirmParam=confirm.confirmParams,
~handleUserError=false,
~manualRetry=isManualRetryEnabled,
)
}
| Some("samsung_pay") =>
switch samsungPayToken {
| SamsungPayTokenOptional(optToken) =>
SamsungPayHelpers.handleSamsungPayClicked(
~componentName,
~sessionObj=optToken->Option.getOr(JSON.Encode.null)->getDictFromJson,
~iframeId,
~readOnly,
)
| _ =>
// TODO - To be replaced with proper error message
intent(
~bodyArr=savedPaymentMethodBody->mergeAndFlattenToTuples(requiredFieldsBody),
~confirmParam=confirm.confirmParams,
~handleUserError=false,
~manualRetry=isManualRetryEnabled,
)
}
| _ =>
intent(
~bodyArr=savedPaymentMethodBody->mergeAndFlattenToTuples(requiredFieldsBody),
~confirmParam=confirm.confirmParams,
~handleUserError=false,
~manualRetry=isManualRetryEnabled,
)
}
} else {
if isUnknownPaymentMethod || confirm.confirmTimestamp < confirm.readyTimestamp {
setUserError(localeString.selectPaymentMethodText)
}
if !isUnknownPaymentMethod && cvcNumber === "" {
setCvcError(_ => localeString.cvcNumberEmptyText)
setUserError(localeString.enterFieldsText)
}
if !(isCVCValid->Option.getOr(false)) {
setUserError(localeString.enterValidDetailsText)
}
if !areRequiredFieldsValid {
setUserError(localeString.enterValidDetailsText)
}
}
}
}, (
areRequiredFieldsValid,
requiredFieldsBody,
empty,
complete,
customerMethod,
applePayToken,
gPayToken,
isManualRetryEnabled,
))
useSubmitPaymentData(submitCallback)
let conditionsForShowingSaveCardCheckbox = React.useMemo(() => {
!isGuestCustomer &&
paymentMethodListValue.payment_type === NEW_MANDATE &&
displaySavedPaymentMethodsCheckbox &&
savedMethods->Array.some(ele => {
ele.paymentMethod === "card" && ele.requiresCvv
})
}, (
isGuestCustomer,
paymentMethodListValue.payment_type,
displaySavedPaymentMethodsCheckbox,
savedMethods,
))
<div className="flex flex-col overflow-auto h-auto no-scrollbar animate-slowShow">
{if (
savedCardlength === 0 &&
clickToPayConfig.isReady->Option.isNone &&
(loadSavedCards === PaymentType.LoadingSavedCards || !showFields)
) {
<PaymentElementShimmer.SavedPaymentCardShimmer />
} else {
<RenderIf condition={!showFields}> {bottomElement} </RenderIf>
}}
<RenderIf condition={conditionsForShowingSaveCardCheckbox}>
<div className="pt-4 pb-2 flex items-center justify-start">
<SaveDetailsCheckbox isChecked=isSaveCardsChecked setIsChecked=setIsSaveCardsChecked />
</div>
</RenderIf>
<RenderIf
condition={displaySavedPaymentMethodsCheckbox &&
paymentMethodListValue.payment_type === SETUP_MANDATE}>
<Terms
mode={Card}
styles={
marginTop: themeObj.spacingGridColumn,
}
/>
</RenderIf>
<RenderIf condition={!showFields}>
<div
className="Label flex flex-row gap-3 items-end cursor-pointer mt-4"
style={
fontSize: "14px",
float: "left",
fontWeight: "500",
width: "fit-content",
color: themeObj.colorPrimary,
}
role="button"
ariaLabel="Click to use more payment methods"
tabIndex=0
onKeyDown={event => {
let key = JsxEvent.Keyboard.key(event)
let keyCode = JsxEvent.Keyboard.keyCode(event)
if key == "Enter" || keyCode == 13 {
setShowFields(_ => true)
}
}}
dataTestId={TestUtils.addNewCardIcon}
onClick={_ => setShowFields(_ => true)}>
<Icon name="circle-plus" size=22 />
{React.string(localeString.morePaymentMethods)}
</div>
</RenderIf>
</div>
}
| 3,236 | 10,395 |
hyperswitch-web
|
src/Components/Radio.res
|
.res
|
@react.component
let make = (
~checked,
~height="15px",
~padding="36%",
~className="default",
~marginTop="0",
~opacity="100%",
~border="2px solid currentColor",
) => {
let class = checked ? "active" : "inactive"
let nonActiveOpacity = checked ? "100%" : opacity
let css = `
input[type="radio"] {
-webkit-appearance: none;
appearance: none;
-moz-appearance: initial;
}
.${className}${class} input[type="radio"] {
visibility: hidden;
}
.${className}${class} input[type="radio"]::before {
border: ${border};
height: ${height};
width: ${height};
border-radius: 50%;
display: block;
content: " ";
opacity: ${nonActiveOpacity};
cursor: pointer;
visibility: visible;
margin-top: ${marginTop};
}
.${className}${class} input[type="radio"]:checked::before {
background: radial-gradient(currentColor ${padding}, transparent 32%);
}`
<>
<style> {React.string(css)} </style>
<div className={`${className}${class} flex self-center`}>
<input type_="radio" className="Radio" checked readOnly=true />
</div>
</>
}
| 299 | 10,396 |
hyperswitch-web
|
src/Components/Input.res
|
.res
|
open RecoilAtoms
@react.component
let make = (
~isValid=None,
~id="",
~setIsValid=?,
~value,
~onChange,
~onBlur=?,
~onKeyDown=?,
~onFocus=?,
~rightIcon=React.null,
~errorString=?,
~fieldName="",
~type_="text",
~maxLength=?,
~pattern=?,
~placeholder="",
~className="",
~inputRef,
) => {
let options = Recoil.useRecoilValueFromAtom(elementOptions)
let {themeObj} = Recoil.useRecoilValueFromAtom(configAtom)
let (_inputFocused, setInputFocused) = React.useState(_ => false)
let {parentURL} = Recoil.useRecoilValueFromAtom(RecoilAtoms.keys)
let setFocus = (val: bool) => {
switch onFocus {
| Some(fn) => fn(val)
| None => ()
}
}
let setValid = val => {
switch setIsValid {
| Some(fn) => fn(_ => val)
| None => ()
}
}
let handleFocus = _ => {
setFocus(true)
setValid(None)
setInputFocused(_ => true)
Utils.handleOnFocusPostMessage(~targetOrigin=parentURL)
}
let handleBlur = ev => {
setFocus(false)
switch onBlur {
| Some(fn) => fn(ev)
| None => ()
}
}
let direction = if type_ == "password" || type_ == "tel" {
"ltr"
} else {
""
}
<div className={` flex flex-col w-full`} style={color: themeObj.colorText}>
<RenderIf condition={fieldName->String.length > 0}>
<div> {React.string(fieldName)} </div>
</RenderIf>
<div className="flex flex-row " style={direction: direction}>
<input
id
style={
background: themeObj.colorBackground,
padding: themeObj.spacingUnit,
width: "100%",
}
disabled=options.disabled
ref={inputRef->ReactDOM.Ref.domRef}
type_
?onKeyDown
?maxLength
?pattern
className={`Input ${className} focus:outline-none transition-shadow ease-out duration-200 border border-gray-300 focus:border-[#006DF9] rounded-md text-sm`}
placeholder
value
onChange
onBlur=handleBlur
onFocus=handleFocus
ariaLabel={`Type to fill ${fieldName} input`}
/>
<div className={`flex -ml-10 items-center`}> {rightIcon} </div>
</div>
{switch errorString {
| Some(val) =>
<RenderIf condition={val->String.length > 0}>
<div
className="py-1 text-xs text-red-600 transition-colors transition-border ease-out duration-200">
{React.string(val)}
</div>
</RenderIf>
| None => React.null
}}
</div>
}
| 677 | 10,397 |
hyperswitch-web
|
src/Components/SurchargeUtils.res
|
.res
|
type oneClickWallets = {
paymentMethodType: string,
displayName: string,
}
let oneClickWallets = [
{paymentMethodType: "apple_pay", displayName: "ApplePay"},
{paymentMethodType: "samsung_pay", displayName: "SamsungPay"},
{paymentMethodType: "paypal", displayName: "Paypal"},
{paymentMethodType: "google_pay", displayName: "GooglePay"},
{paymentMethodType: "klarna", displayName: "Klarna"},
]
type walletSurchargeDetails = {
name: string,
surchargeDetails: PaymentMethodsRecord.surchargeDetails,
}
let useSurchargeDetailsForOneClickWallets = (~paymentMethodListValue) => {
let areOneClickWalletsRendered = Recoil.useRecoilValueFromAtom(
RecoilAtoms.areOneClickWalletsRendered,
)
React.useMemo(() => {
oneClickWallets->Array.reduce([], (acc, wallet) => {
let (isWalletBtnRendered, paymentMethod) = switch wallet.paymentMethodType {
| "apple_pay" => (areOneClickWalletsRendered.isApplePay, "wallet")
| "samsung_pay" => (areOneClickWalletsRendered.isSamsungPay, "wallet")
| "paypal" => (areOneClickWalletsRendered.isPaypal, "wallet")
| "google_pay" => (areOneClickWalletsRendered.isGooglePay, "wallet")
| "klarna" => (areOneClickWalletsRendered.isKlarna, "pay_later")
| _ => (false, "")
}
if isWalletBtnRendered {
let paymentMethodType =
PaymentMethodsRecord.getPaymentMethodTypeFromList(
~paymentMethodListValue,
~paymentMethod,
~paymentMethodType=wallet.paymentMethodType,
)->Option.getOr(PaymentMethodsRecord.defaultPaymentMethodType)
switch paymentMethodType.surcharge_details {
| Some(surchargDetails) =>
acc->Array.concat([
{
name: wallet.displayName,
surchargeDetails: surchargDetails,
},
])
| None => acc
}
} else {
acc
}
})
}, (areOneClickWalletsRendered, paymentMethodListValue))
}
let useMessageGetter = () => {
let {localeString} = Recoil.useRecoilValueFromAtom(RecoilAtoms.configAtom)
let {showShortSurchargeMessage} = Recoil.useRecoilValueFromAtom(RecoilAtoms.optionAtom)
let getMessage = (
~surchargeDetails: PaymentMethodsRecord.surchargeDetails,
~paymentMethod,
~paymentMethodListValue: PaymentMethodsRecord.paymentMethodList,
) => {
let currency = paymentMethodListValue.currency
let surchargeValue = surchargeDetails.displayTotalSurchargeAmount->Float.toString
if showShortSurchargeMessage {
Some(localeString.shortSurchargeMessage(currency, surchargeValue))
} else {
let message = if paymentMethod === "card" {
localeString.surchargeMsgAmountForCard(currency, surchargeValue)
} else {
localeString.surchargeMsgAmount(currency, surchargeValue)
}
Some(message)
}
}
getMessage
}
let useOneClickWalletsMessageGetter = (~paymentMethodListValue) => {
let {localeString} = Recoil.useRecoilValueFromAtom(RecoilAtoms.configAtom)
let oneClickWalletsArr = useSurchargeDetailsForOneClickWallets(~paymentMethodListValue)
let getOneClickWalletsMessage = () => {
if oneClickWalletsArr->Array.length !== 0 {
let msg = oneClickWalletsArr->Array.reduceWithIndex(React.null, (acc, wallet, index) => {
let amount = wallet.surchargeDetails.displayTotalSurchargeAmount->Float.toString
let myMsg =
<>
<strong> {React.string(`${paymentMethodListValue.currency} ${amount}`)} </strong>
{React.string(`${Utils.nbsp}${localeString.on} ${wallet.name}`)}
</>
let msgToConcat = if index === 0 {
myMsg
} else if index === oneClickWalletsArr->Array.length - 1 {
<>
{React.string(`${Utils.nbsp}${localeString.\"and"}${Utils.nbsp}`)}
{myMsg}
</>
} else {
<>
{React.string(`,${Utils.nbsp}`)}
{myMsg}
</>
}
<>
{acc}
{msgToConcat}
</>
})
let finalElement =
<>
{React.string(`${localeString.surchargeMsgAmountForOneClickWallets}:${Utils.nbsp}`)}
{msg}
</>
Some(finalElement)
} else {
None
}
}
getOneClickWalletsMessage
}
| 1,055 | 10,398 |
hyperswitch-web
|
src/Components/CryptoCurrencyNetworks.res
|
.res
|
@react.component
let make = () => {
open DropdownField
let currencyVal = Recoil.useRecoilValueFromAtom(RecoilAtoms.userCurrency)
let {config, localeString} = Recoil.useRecoilValueFromAtom(RecoilAtoms.configAtom)
let (cryptoCurrencyNetworks, setCryptoCurrencyNetworks) = Recoil.useRecoilState(
RecoilAtoms.cryptoCurrencyNetworks,
)
let dropdownOptions =
Utils.currencyNetworksDict
->Dict.get(currencyVal)
->Option.getOr([])
->Array.map(item => {
label: Utils.toSpacedUpperCase(~str=item, ~delimiter="_"),
value: item,
})
let initialValue = (
dropdownOptions
->Array.get(0)
->Option.getOr({
label: "",
value: "",
})
).value
React.useEffect(() => {
setCryptoCurrencyNetworks(_ => initialValue)
None
}, [initialValue])
<DropdownField
appearance=config.appearance
fieldName=localeString.currencyNetwork
value=cryptoCurrencyNetworks
setValue=setCryptoCurrencyNetworks
disabled=false
options=dropdownOptions
/>
}
| 257 | 10,399 |
hyperswitch-web
|
src/Components/PayNowButton.res
|
.res
|
@send external postMessage: (Window.window, JSON.t, string) => unit = "postMessage"
module Loader = {
@react.component
let make = () => {
let {themeObj} = Recoil.useRecoilValueFromAtom(RecoilAtoms.configAtom)
<div className=" w-8 h-8 animate-spin" style={color: themeObj.colorTextSecondary}>
<Icon size=32 name="loader" />
</div>
}
}
@react.component
let make = (~onClickHandler=?, ~label=?) => {
open RecoilAtoms
open Utils
let (showLoader, setShowLoader) = React.useState(() => false)
let (isPayNowButtonDisable, setIsPayNowButtonDisable) = React.useState(() => false)
let {themeObj, localeString} = configAtom->Recoil.useRecoilValueFromAtom
let {sdkHandleConfirmPayment} = optionAtom->Recoil.useRecoilValueFromAtom
let confirmPayload = sdkHandleConfirmPayment->PaymentBody.confirmPayloadForSDKButton
let buttonText = switch label {
| Some(val) => val
| None => sdkHandleConfirmPayment.buttonText->Option.getOr(localeString.payNowButton)
}
let handleMessage = (event: Types.event) => {
let json = event.data->Identity.anyTypeToJson->getStringFromJson("")->safeParse
let dict = json->getDictFromJson
switch dict->Dict.get("submitSuccessful") {
| Some(submitSuccessfulVal) =>
if !(submitSuccessfulVal->JSON.Decode.bool->Option.getOr(false)) {
setIsPayNowButtonDisable(_ => false)
setShowLoader(_ => false)
}
| None => ()
}
}
let onClickHandlerFunc = _ => {
switch onClickHandler {
| Some(fn) => fn()
| None => ()
}
}
let handleOnClick = _ => {
setIsPayNowButtonDisable(_ => true)
setShowLoader(_ => true)
EventListenerManager.addSmartEventListener("message", handleMessage, "onSubmitSuccessful")
messageParentWindow([("handleSdkConfirm", confirmPayload)])
}
<div className="flex flex-col gap-1 h-auto w-full items-center">
<button
disabled=isPayNowButtonDisable
onClick={onClickHandler->Option.isNone ? handleOnClick : onClickHandlerFunc}
className={`w-full flex flex-row justify-center items-center`}
style={
borderRadius: themeObj.buttonBorderRadius,
backgroundColor: themeObj.buttonBackgroundColor,
height: themeObj.buttonHeight,
cursor: {isPayNowButtonDisable ? "not-allowed" : "pointer"},
opacity: {isPayNowButtonDisable ? "0.6" : "1"},
width: themeObj.buttonWidth,
border: `${themeObj.buttonBorderWidth} solid ${themeObj.buttonBorderColor}`,
}>
<span
id="button-text"
style={
color: themeObj.buttonTextColor,
fontSize: themeObj.buttonTextFontSize,
fontWeight: themeObj.buttonTextFontWeight,
}>
{if showLoader {
<Loader />
} else {
buttonText->React.string
}}
</span>
</button>
</div>
}
| 692 | 10,400 |
hyperswitch-web
|
src/Components/InputField.res
|
.res
|
open RecoilAtoms
@react.component
let make = (
~isValid,
~id="",
~setIsValid,
~value,
~onChange,
~onBlur,
~onKeyDown=?,
~onFocus=?,
~rightIcon=React.null,
~errorString=?,
~errorStringClasses=?,
~fieldName="",
~type_="text",
~paymentType: CardThemeType.mode,
~maxLength=?,
~pattern=?,
~placeholder="",
~className="",
~inputRef,
~isFocus,
~labelClassName="",
) => {
open ElementType
let (eleClassName, setEleClassName) = React.useState(_ => "input-base")
let {iframeId, parentURL} = Recoil.useRecoilValueFromAtom(keys)
let options = Recoil.useRecoilValueFromAtom(elementOptions)
let setFocus = (val: bool) => {
switch onFocus {
| Some(fn) => fn(val)
| None => ()
}
}
let setClass = val => {
switch paymentType {
| Card
| CardCVCElement
| CardExpiryElement
| CardNumberElement
| PaymentMethodCollectElement =>
setEleClassName(_ => val)
| _ => ()
}
}
let textColor = switch isValid {
| Some(val) => val ? "" : "#eb1c26"
| None => ""
}
let setValidClasses = () => {
switch isValid {
| Some(val) => val ? setClass("input-complete") : setClass("input-invalid")
| None => setClass("input-base")
}
}
let handleFocus = _ => {
if value->String.length == 0 {
setClass("input-empty")
} else if value->String.length > 0 {
setValidClasses()
}
setFocus(true)
setIsValid(_ => None)
Utils.handleOnFocusPostMessage(~targetOrigin=parentURL)
}
let handleBlur = ev => {
if value->String.length == 0 {
setClass("input-base")
} else if value->String.length > 0 {
setValidClasses()
}
setFocus(false)
onBlur(ev)
Utils.handleOnBlurPostMessage(~targetOrigin=parentURL)
}
React.useEffect(() => {
if value->String.length > 0 {
setValidClasses()
}
None
}, (value, isValid))
let direction = if type_ == "password" || type_ == "tel" {
"ltr"
} else {
""
}
let isValidValue = CardUtils.getBoolOptionVal(isValid)
let (cardEmpty, cardComplete, cardInvalid, cardFocused) = React.useMemo(() => {
let isCardDetailsEmpty =
String.length(value) == 0
? `${options.classes.base} ${options.classes.empty} `
: options.classes.base
let isCardDetailsValid = isValidValue == "valid" ? ` ${options.classes.complete} ` : ""
let isCardDetailsInvalid = isValidValue == "invalid" ? ` ${options.classes.invalid} ` : ""
let isCardDetailsFocused = isFocus ? ` ${options.classes.focus} ` : ""
(isCardDetailsEmpty, isCardDetailsValid, isCardDetailsInvalid, isCardDetailsFocused)
}, (isValid, setIsValid, value, onChange, onBlur))
let concatString = Array.joinWith([cardEmpty, cardComplete, cardInvalid, cardFocused], "")
React.useEffect(() => {
Utils.messageParentWindow([
("id", iframeId->JSON.Encode.string),
("concatedString", concatString->JSON.Encode.string),
])
None
}, (isValid, setIsValid, value, onChange, onBlur))
<div className={` flex flex-col w-full`}>
<RenderIf condition={fieldName->String.length > 0}>
<div className={`${labelClassName}`}> {React.string(fieldName)} </div>
</RenderIf>
<div className="flex flex-row " style={direction: direction}>
<input
id
style={
background: "transparent",
width: "-webkit-fill-available",
color: textColor,
}
disabled=options.disabled
ref={inputRef->ReactDOM.Ref.domRef}
type_
?onKeyDown
?maxLength
?pattern
className={`${eleClassName} ${className} focus:outline-none transition-shadow ease-out duration-200`}
placeholder
value
onChange
onBlur=handleBlur
onFocus=handleFocus
ariaLabel={`Type to fill ${fieldName} input`}
/>
<div className={`flex -ml-10 items-center`}> {rightIcon} </div>
</div>
{
let errorClases = errorStringClasses->Option.getOr("")
switch errorString {
| Some(val) =>
<RenderIf condition={val->String.length > 0}>
<div className={`py-1 ${errorClases}`}> {React.string(val)} </div>
</RenderIf>
| None => React.null
}
}
</div>
}
| 1,117 | 10,401 |
hyperswitch-web
|
src/Components/PaymentShimmer.res
|
.res
|
@react.component
let make = (~showInBlock=true) => {
open PaymentElementShimmer
let {themeObj} = Recoil.useRecoilValueFromAtom(RecoilAtoms.configAtom)
let bottomElement =
<Shimmer classname="opacity-50">
<div
className="w-full h-2 animate-pulse"
style={backgroundColor: themeObj.colorPrimary, opacity: "10%"}
/>
</Shimmer>
if showInBlock {
<Block bottomElement />
} else {
{bottomElement}
}
}
| 124 | 10,402 |
hyperswitch-web
|
src/Components/PaymentRequestButtomShimmer.res
|
.res
|
module Shimmer = {
@react.component
let make = (~children) => {
<div
className="relative
before:absolute before:inset-0
before:-translate-x-full
before:animate-[shimmer_1s_infinite]
before:bg-gradient-to-r
before:px-1
before: rounded
before:from-transparent before:via-slate-200 before:to-transparent overflow-hidden w-full">
children
</div>
}
}
@react.component
let make = () => {
<div className="flex flex-col gap-4">
<Shimmer>
<div className="animate-pulse w-full h-12 rounded bg-slate-200 flex justify-around ">
<div className="flex flex-col items-center gap-2 place-content-center">
<div className=" w-36 h-2 rounded p-1 bg-white bg-opacity-70 " />
<div className=" w-24 h-2 rounded p-1 bg-white bg-opacity-70 " />
</div>
</div>
</Shimmer>
</div>
}
| 248 | 10,403 |
hyperswitch-web
|
src/Components/EmailPaymentInput.res
|
.res
|
open RecoilAtoms
open Utils
@react.component
let make = (~paymentType) => {
let {localeString} = Recoil.useRecoilValueFromAtom(configAtom)
let loggerState = Recoil.useRecoilValueFromAtom(loggerAtom)
let (email, setEmail) = Recoil.useLoggedRecoilState(userEmailAddress, "email", loggerState)
let {fields} = Recoil.useRecoilValueFromAtom(optionAtom)
let showDetails = PaymentType.getShowDetails(
~billingDetails=fields.billingDetails,
~logger=loggerState,
)
let emailRef = React.useRef(Nullable.null)
let changeEmail = ev => {
let val: string = ReactEvent.Form.target(ev)["value"]
setEmail(prev => {
value: val,
isValid: val->isEmailValid,
errorString: val->isEmailValid->Option.getOr(false) ? "" : prev.errorString,
})
}
let onBlur = ev => {
let val = ReactEvent.Focus.target(ev)["value"]
setEmail(prev => {
...prev,
isValid: val->isEmailValid,
})
}
React.useEffect(() => {
setEmail(prev => {
...prev,
errorString: switch prev.isValid {
| Some(val) => val ? "" : localeString.emailInvalidText
| None => ""
},
})
None
}, [email.isValid])
let submitCallback = React.useCallback((ev: Window.event) => {
let json = ev.data->safeParse
let confirm = json->getDictFromJson->ConfirmType.itemToObjMapper
if confirm.doSubmit {
if email.value == "" {
setEmail(prev => {
...prev,
errorString: localeString.emailEmptyText,
})
}
}
}, [email])
useSubmitPaymentData(submitCallback)
<RenderIf condition={showDetails.email == Auto}>
<PaymentField
fieldName=localeString.emailLabel
setValue={setEmail}
value=email
onChange=changeEmail
onBlur
paymentType
type_="email"
inputRef=emailRef
placeholder="Eg: [email protected]"
name=TestUtils.emailInputTestId
/>
</RenderIf>
}
| 490 | 10,404 |
hyperswitch-web
|
src/Components/Spinner.res
|
.res
|
@react.component
let make = () => {
let {themeObj} = Recoil.useRecoilValueFromAtom(RecoilAtoms.configAtom)
<div className=" w-8 h-8 animate-spin" style={color: themeObj.colorTextSecondary}>
<Icon size=32 name="loader" />
</div>
}
| 73 | 10,405 |
hyperswitch-web
|
src/Components/ClickToPayDetails.res
|
.res
|
@react.component
let make = (
~isSaveDetailsWithClickToPay,
~setIsSaveDetailsWithClickToPay,
~clickToPayCardBrand,
~clickToPayRememberMe,
~setClickToPayRememberMe,
) => {
let clickToPayConfig = Recoil.useRecoilValueFromAtom(RecoilAtoms.clickToPayConfig)
let {themeObj} = Recoil.useRecoilValueFromAtom(RecoilAtoms.configAtom)
let {iframeId} = Recoil.useRecoilValueFromAtom(RecoilAtoms.keys)
let isUnrecognizedUser = clickToPayConfig.clickToPayCards->Option.getOr([])->Array.length == 0
let css = SaveDetailsCheckbox.saveDetailsCssStyle(themeObj)
let getPrivacyNoticeUrl = () => {
switch String.toLowerCase(clickToPayCardBrand) {
| "mastercard" => "https://www.mastercard.com/global/click-to-pay/en-us/privacy-notice.html"
| "visa" => "https://www.visa.com.hk/en_HK/legal/global-privacy-notice.html"
| _ => "https://www.mastercard.com/global/click-to-pay/en-us/privacy-notice.html"
}
}
let getTermsUrl = () => {
switch String.toLowerCase(clickToPayCardBrand) {
| "mastercard" => "https://www.mastercard.com/global/click-to-pay/en-us/terms-of-use.html"
| "visa" => "https://www.visa.com.hk/en_HK/legal/visa-checkout/terms-of-service.html"
| _ => "https://www.mastercard.com/global/click-to-pay/en-us/terms-of-use.html"
}
}
let handleOpenUrl = (event: ReactEvent.Mouse.t, url: string) => {
ReactEvent.Mouse.preventDefault(event)
let _ = Window.windowOpen(url, "_blank", "")
}
let capitalizeCardBrand = (brand: string) => {
String.toUpperCase(String.substring(brand, ~start=0, ~end=1)) ++
String.substring(brand, ~start=1, ~end=String.length(brand))
}
let formattedCardBrand = capitalizeCardBrand(clickToPayCardBrand)
let getIsChecked = ev => {
let target = ev->ReactEvent.Form.target
target["checked"]
}
let (
isSaveDetailsCheckboxState,
isSaveDetailsCheckedState,
isSaveDetailsCheckBoxLabelState,
) = isSaveDetailsWithClickToPay
? ("Checkbox--checked", "CheckboxInput--checked", "CheckboxLabel--checked")
: ("", "", "")
let (
isRememberMeCheckboxState,
isRememberMeCheckedState,
isRememberMeCheckBoxLabelState,
) = clickToPayRememberMe
? ("Checkbox--checked", "CheckboxInput--checked", "CheckboxLabel--checked")
: ("", "", "")
let handleLearnMore = _ => {
let cardBrands =
clickToPayConfig.availableCardBrands->Array.map(brand => brand->JSON.Encode.string)
Utils.messageParentWindow([
("fullscreen", true->JSON.Encode.bool),
("param", `clickToPayLearnMore`->JSON.Encode.string),
("iframeId", iframeId->JSON.Encode.string),
("metadata", [("cardBrands", cardBrands->JSON.Encode.array)]->Utils.getJsonFromArrayOfJson),
])
}
<>
<style> {React.string(css)} </style>
{!isUnrecognizedUser
? <div className="text-xs font-normal">
{React.string(
`By continuing, ${clickToPayConfig.dpaName} will share your card details, billing address,
and email with ${formattedCardBrand} to allow you to securely enroll in Click to
Pay for faster checkouts.`,
)}
{React.string(" ")}
<span
className="underline decoration-1 underline-offset-2 cursor-pointer"
onClick={handleLearnMore}>
{React.string("Learn more")}
</span>
</div>
: <>
<style> {React.string(css)} </style>
<div className={`Checkbox ${isSaveDetailsCheckboxState} flex`}>
<label
className={`container CheckboxInput ${isSaveDetailsCheckedState}`}
style={width: "fit-content"}>
<input
type_={`checkbox`} onChange={e => setIsSaveDetailsWithClickToPay(e->getIsChecked)}
/>
<div className={`checkmark CheckboxInput ${isSaveDetailsCheckedState}`} />
</label>
<div
className={`CheckboxLabel ${isSaveDetailsCheckBoxLabelState} ml-2 w-11/12 text-xs space-y-2`}
style={color: "#a9a9a9"}>
<div>
{React.string(`Save my information with ${formattedCardBrand} `)}
<span
className="underline decoration-1 underline-offset-2 cursor-pointer"
onClick={handleLearnMore}>
{React.string("Click to Pay")}
</span>
{React.string(" ")}
{React.string("for a faster and secure checkout")}
</div>
<div>
{React.string("Your email or mobile number will be used to verify you.")}
{React.string("Message/data rates may apply.")}
</div>
</div>
</div>
<div className={`Checkbox ${isRememberMeCheckboxState} flex`}>
<label
className={`container CheckboxInput ${isRememberMeCheckedState}`}
style={width: "fit-content"}>
<input type_={`checkbox`} onChange={e => setClickToPayRememberMe(e->getIsChecked)} />
<div className={`checkmark CheckboxInput ${isRememberMeCheckedState}`} />
</label>
<div
className={`CheckboxLabel ${isRememberMeCheckBoxLabelState} ml-2 w-11/12 text-xs space-y-2`}
style={color: "#a9a9a9"}>
<div className="flex items-center">
{React.string("Remember me on this browser")}
<div className="relative inline-block ml-2">
<div className="group cursor-help">
<div
className="w-4 h-4 rounded-full bg-[#4a4a4a] flex items-center justify-center cursor-help">
<span className="text-white text-xs cursor-help" style={fontSize: "10px"}>
{React.string("i")}
</span>
</div>
<div
className="invisible group-hover:visible absolute z-10 w-64 bg-white text-xs rounded-md p-2 left-1/2 transform -translate-x-1/2 bottom-[150%] shadow-md border border-gray-200 before:content-[''] before:absolute before:top-[100%] before:left-1/2 before:ml-[-5px] before:border-[5px] before:border-solid before:border-gray-200 before:border-b-transparent before:border-l-transparent before:border-r-transparent after:content-[''] after:absolute after:top-[100%] after:left-1/2 after:ml-[-4px] after:border-[4px] after:border-solid after:border-white after:border-b-transparent after:border-l-transparent after:border-r-transparent">
// {/* Content */}
<div className="flex flex-col space-y-2">
<span>
{React.string("When remembered, you'll skip verification and securely")}
{React.string("access your saved cards when paying with Click to Pay.")}
</span>
<span>
{React.string("Not recommended for public or shared devices because")}
{React.string("this uses cookies.")}
</span>
</div>
</div>
</div>
</div>
</div>
<div>
{React.string(`By continuing, you agree to ${formattedCardBrand}'s `)}
<span
className="underline decoration-1 underline-offset-2 cursor-pointer"
onClick={ev => handleOpenUrl(ev, getTermsUrl())}>
{React.string("Terms")}
</span>
{React.string(" ")}
{React.string("and understand your data will be processed according to the ")}
<span
className="underline decoration-1 underline-offset-2 cursor-pointer"
onClick={ev => handleOpenUrl(ev, getPrivacyNoticeUrl())}>
{React.string("Privacy Notice")}
</span>
{React.string(".")}
</div>
</div>
</div>
</>}
</>
}
| 1,842 | 10,406 |
hyperswitch-web
|
src/Components/Modal.res
|
.res
|
let close = setOpenModal => {
setOpenModal(_ => false)
setTimeout(() => {
Utils.messageParentWindow([("fullscreen", false->JSON.Encode.bool)])
}, 450)->ignore
}
@react.component
let make = (
~children,
~closeCallback=?,
~loader=false,
~showClose=true,
~testMode=true,
~setOpenModal,
~openModal,
) => {
let {themeObj} = Recoil.useRecoilValueFromAtom(RecoilAtoms.configAtom)
let closeModal = () => {
setOpenModal(_ => false)
switch closeCallback {
| Some(fn) => fn()
| None => setTimeout(() => {
Utils.messageParentWindow([("fullscreen", false->JSON.Encode.bool)])
}, 450)->ignore
}
}
React.useEffect(() => {
loader ? setOpenModal(_ => false) : setOpenModal(_ => true)
None
}, [loader])
let loaderVisibility = loader ? "visible" : "hidden"
let contentVisibility = React.useMemo(() => {
!openModal ? "hidden" : "visible"
}, [openModal])
let marginTop = testMode ? "mt-8" : "mt-6"
let animate = contentVisibility == "visible" ? "animate-zoomIn" : "animate-zoomOut"
let loaderUI =
<div className={`flex justify-center m-auto ${loaderVisibility}`}>
<Loader showText=false />
</div>
<div
className="h-screen w-screen bg-black/40 flex m-auto items-center backdrop-blur-sm overflow-scroll"
style={
transition: "opacity .35s ease .1s,background-color 600ms linear",
opacity: !openModal ? "0" : "100",
}>
{loaderUI}
{<div
className={`w-full h-full sm:h-auto sm:w-[55%] md:w-[45%] lg:w-[35%] xl:w-[32%] 2xl:w-[27%] m-auto bg-white flex flex-col justify-start sm:justify-center px-5 pb-5 md:pb-6 pt-4 md:pt-7 rounded-none sm:rounded-md relative overflow-scroll ${animate}`}
style={
transition: "opacity .35s ease .1s,transform .35s ease .1s,-webkit-transform .35s ease .1s",
opacity: !openModal ? "0" : "100",
backgroundColor: {
themeObj.colorBackground === "transparent"
? ""
: themeObj.colorBackground->Utils.rgbaTorgb
},
}>
<div className="absolute top-0 left-0 w-full flex flex-col">
<RenderIf condition={testMode && !GlobalVars.isProd}>
<div
className="w-full h-6 text-[#885706] bg-[#FDD486] text-xs flex justify-center items-center font-semibold">
{React.string("TEST DATA")}
</div>
</RenderIf>
<RenderIf condition=showClose>
<div
className="p-4 flex justify-end self-end mb-4 cursor-pointer"
onClick={_ => closeModal()}>
<Icon name="cross" size=23 />
</div>
</RenderIf>
</div>
<div className={`mt-12 sm:${marginTop}`}> children </div>
</div>}
</div>
}
| 766 | 10,407 |
hyperswitch-web
|
src/Components/AddBankAccount.res
|
.res
|
open RecoilAtoms
open Utils
module ToolTip = {
@react.component
let make = (~openTip, ~forwardRef, ~onclick) => {
let {themeObj} = Recoil.useRecoilValueFromAtom(configAtom)
<RenderIf condition={openTip}>
<button
className="h-auto max-w-30 w-auto cursor-pointer absolute m-1 px-1 py-2 top-[-3rem] right-[1em]"
style={
background: themeObj.colorBackground,
color: themeObj.colorDanger,
fontSize: themeObj.fontSizeBase,
padding: `${themeObj.spacingUnit} ${themeObj.spacingUnit->Utils.addSize(
7.0,
Utils.Pixel,
)}`,
border: `1px solid ${themeObj.borderColor}`,
borderRadius: themeObj.borderRadius,
boxShadow: `0px 0px 8px ${themeObj.borderColor}`,
}
onClick={ev => onclick(ev)}
ref={forwardRef->ReactDOM.Ref.domRef}>
{React.string("Remove account")}
</button>
</RenderIf>
}
}
@react.component
let make = (~modalData, ~setModalData) => {
let isDataAvailable = modalData->Option.isSome
let {themeObj, localeString, config} = Recoil.useRecoilValueFromAtom(configAtom)
let {iframeId} = Recoil.useRecoilValueFromAtom(keys)
let (openToolTip, setOpenToolTip) = React.useState(_ => false)
let toolTipRef = React.useRef(Nullable.null)
let openModal = () => {
let metaData = [("config", config->Identity.anyTypeToJson)]->getJsonFromArrayOfJson
messageParentWindow([
("fullscreen", true->JSON.Encode.bool),
("iframeId", iframeId->JSON.Encode.string),
("metadata", metaData),
])
}
<div
className={`PickerItem flex flex-row justify-between items-center ${isDataAvailable
? ""
: "cursor-pointer"}`}
style={
marginTop: themeObj.spacingGridColumn,
padding: themeObj.spacingUnit->addSize(11.0, Pixel),
color: {
isDataAvailable ? themeObj.colorTextSecondary : themeObj.colorPrimary
},
}
tabIndex={0}
ariaLabel="Click to Add bank account"
onClick={_ => isDataAvailable ? () : openModal()}>
{switch modalData {
| Some(data: ACHTypes.data) =>
let last4digts =
data.iban !== ""
? data.iban->CardUtils.clearSpaces->String.sliceToEnd(~start=-4)
: data.accountNumber->String.sliceToEnd(~start=-4)
<div className="flex flex-row justify-between w-full relative animate-slowShow">
<div className="flex flex-row gap-4">
<div>
<Icon size=22 name="bank" />
</div>
<div className="tracking-wider"> {React.string(`Bank **** ${last4digts}`)} </div>
</div>
<ToolTip
openTip=openToolTip forwardRef=toolTipRef onclick={_ => {setModalData(_ => None)}}
/>
<div
className="PickerAction self-center w-auto cursor-pointer"
onClick={_ => setOpenToolTip(_ => true)}>
<Icon size=22 name="three-dots" />
</div>
</div>
| None =>
<>
<div className="flex flex-row gap-4 animate-slowShow">
<div>
<Icon size=22 name="bank" />
</div>
<div ariaHidden=true> {React.string(localeString.addBankAccount)} </div>
</div>
<div className="PickerAction self-center">
<Icon size=22 name="caret-right" />
</div>
</>
}}
</div>
}
| 840 | 10,408 |
hyperswitch-web
|
src/Components/ClickToPayNotYou.res
|
.res
|
open ClickToPayHelpers
open Utils
@react.component
let make = (~setIsShowClickToPayNotYou, ~isCTPAuthenticateNotYouClicked, ~setConsumerIdentity) => {
let {themeObj} = Recoil.useRecoilValueFromAtom(RecoilAtoms.configAtom)
let (clickToPayConfig, setClickToPayConfig) = Recoil.useRecoilState(RecoilAtoms.clickToPayConfig)
let (identifier, setIdentifier) = React.useState(_ => "")
let (isValid, setIsValid) = React.useState(_ => false)
let (identifierType, setIdentifierType) = React.useState(_ => EMAIL_ADDRESS)
let onContinue = consumerIdentity => {
open Promise
ClickToPayHelpers.signOut()
->finally(() => {
setClickToPayConfig(prev => {
...prev,
clickToPayCards: Some([]),
})
setIsShowClickToPayNotYou(_ => false)
setConsumerIdentity(_ => consumerIdentity)
})
->catch(err => resolve(Error(err)))
->ignore
}
let onBack = _ => {
setIsShowClickToPayNotYou(_ => false)
}
let countryAndCodeCodeList =
phoneNumberJson
->JSON.Decode.object
->Option.getOr(Dict.make())
->getArray("countries")
let countryCodes = countryAndCodeCodeList->Array.map(countryObj => {
let countryObjDict = countryObj->getDictFromJson
let countryCode = countryObjDict->getString("phone_number_code", "")
let countryName = countryObjDict->getString("country_code", "")
{code: countryCode, countryISO: countryName}
})
let (countryCode, setCountryCode) = React.useState(() =>
(countryCodes->Array.get(0)->Option.getOr(defaultCountry)).countryISO
)
let validateIdentifier = (value, identityType: identityType) => {
let emailRegex = %re("/^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/")
let phoneRegex = %re("/^\d{6,14}$/")
switch identityType {
| EMAIL_ADDRESS => emailRegex->RegExp.test(value)
| MOBILE_PHONE_NUMBER => phoneRegex->RegExp.test(value)
}
}
let formatPhoneNumber: string => string = value => {
if String.startsWith(value, "+") {
if String.includes(value, " ") {
value
} else {
String.replaceRegExp(value, %re("/^\+(\d{1,3})(\d+)$/"), "+$1 $2")
}
} else if String.match(value, %re("/^\d+$/"))->Option.isSome {
`+${value}`
} else {
value
}
}
let handleInputChange = ev => {
let target = ev->ReactEvent.Form.target
let newValue = target["value"]
let formattedValue =
identifierType === MOBILE_PHONE_NUMBER ? newValue->formatPhoneNumber : newValue
setIdentifier(_ => formattedValue)
}
let handleTypeChange = ev => {
let target = ev->ReactEvent.Form.target
let newValue = target["value"]
setIdentifierType(_ => newValue)
setIdentifier(_ => "") // Clear the input when changing type
}
let handleCountryCodeChange = ev => {
let target = ev->ReactEvent.Form.target
let newValue = target["value"]
setCountryCode(_ => newValue)
}
let handlePhoneInputChange = ev => {
let target = ev->ReactEvent.Form.target
let newValue = target["value"]->String.replaceRegExp(%re("/\\D/g"), "") // Remove non-digit characters
setIdentifier(_ => newValue)
}
React.useEffect(() => {
setIsValid(_ => validateIdentifier(identifier, identifierType))
None
}, (identifier, identifierType))
let handleSubmit = e => {
e->ReactEvent.Form.preventDefault
if isValid {
let country =
countryCodes
->Array.find(country => countryCode === country.countryISO)
->Option.getOr(defaultCountry)
let submittedIdentifier =
identifierType === MOBILE_PHONE_NUMBER
? String.sliceToEnd(country.code, ~start=1) ++ " " ++ identifier
: identifier
onContinue({identityValue: submittedIdentifier, identityType: identifierType})
}
}
let _maskedEmail = (~onNotYouClick) => {
<div className="flex space-x-2 text-sm text-[#484848]">
<button
onClick={onNotYouClick} className="underline cursor-pointer [text-underline-offset:0.2rem]">
{React.string("Not you?")}
</button>
</div>
}
<div className="p-4 bg-white rounded-lg border border-[#E6E1E1] flex flex-col space-y-4">
<div className="flex flex-col">
<RenderIf condition={!isCTPAuthenticateNotYouClicked}>
<button onClick={onBack}>
<Icon name="arrow-back" size=16 />
</button>
</RenderIf>
<div className="flex justify-center items-center">
<div>
<ClickToPayHelpers.SrcMark
cardBrands={clickToPayConfig.availableCardBrands->Array.joinWith(",")} height="32"
/>
</div>
</div>
</div>
<div className="flex flex-col justify-center items-center space-y-4 px-4">
<p className="text-sm font-normal">
{React.string(
"Enter a new email or mobile number to access a different set of linked cards.",
)}
</p>
<form
onSubmit={handleSubmit}
className="w-full flex flex-col justify-center items-center space-y-4">
<div className="w-full flex space-x-2">
<div className="relative w-1/3">
<select
value={identifierType->getIdentityType}
onChange={handleTypeChange}
className="w-full p-3 pr-10 border border-gray-300 rounded-md appearance-none">
<option value={EMAIL_ADDRESS->getIdentityType}> {React.string("Email")} </option>
<option value={MOBILE_PHONE_NUMBER->getIdentityType}>
{React.string("Phone")}
</option>
</select>
<div
className="absolute inset-y-0 right-4 flex items-center selection:pointer-events-none">
<Icon
className="absolute z-10 pointer pointer-events-none" name="arrow-down" size=10
/>
</div>
</div>
{identifierType === EMAIL_ADDRESS
? <input
type_="text"
value={identifier}
onChange={handleInputChange}
placeholder="Enter email"
className="w-2/3 p-3 border border-gray-300 rounded-md"
required=true
/>
: <div className="w-2/3 flex border border-gray-300 rounded-md overflow-hidden">
<div className="relative">
<select
value={countryCode}
onChange={handleCountryCodeChange}
className="h-full p-3 appearance-none focus:outline-none">
{countryCodes
->Array.map(country =>
<option
key={`${country.code}-${country.countryISO}`} value={country.countryISO}>
{React.string(`${country.countryISO} ${country.code}`)}
</option>
)
->React.array}
</select>
<div
className="absolute inset-y-0 right-4 flex items-center selection:pointer-events-none">
<Icon
className="absolute z-10 pointer pointer-events-none"
name="arrow-down"
size=10
/>
</div>
</div>
<input
type_="tel"
value={identifier}
onChange={handlePhoneInputChange}
placeholder="Mobile number"
className="flex-grow p-3 focus:outline-none w-full"
required=true
/>
</div>}
</div>
<button
type_="submit"
className={`w-full p-3 ${isValid ? "" : "opacity-50 cursor-not-allowed"}`}
style={
backgroundColor: themeObj.buttonBackgroundColor,
color: themeObj.buttonTextColor,
borderRadius: themeObj.buttonBorderRadius,
fontSize: themeObj.buttonTextFontSize,
}
disabled={!isValid}>
{React.string("Switch ID")}
</button>
</form>
</div>
</div>
}
module ClickToPayNotYouText = {
@react.component
let make = (~setIsShowClickToPayNotYou) => {
let onNotYouClick = _ => {
setIsShowClickToPayNotYou(_ => true)
}
<div className="flex space-x-2 text-sm text-[#484848]">
<button
onClick={onNotYouClick} className="underline cursor-pointer [text-underline-offset:0.2rem]">
{React.string("Not you?")}
</button>
</div>
}
}
| 1,976 | 10,409 |
hyperswitch-web
|
src/Components/SavedPaymentManagement.res
|
.res
|
@react.component
let make = (~savedMethods: array<PaymentType.customerMethods>, ~setSavedMethods) => {
open CardUtils
open Utils
open RecoilAtoms
let {iframeId} = Recoil.useRecoilValueFromAtom(keys)
let {config} = Recoil.useRecoilValueFromAtom(configAtom)
let customPodUri = Recoil.useRecoilValueFromAtom(customPodUri)
let logger = Recoil.useRecoilValueFromAtom(loggerAtom)
let removeSavedMethod = (savedMethods: array<PaymentType.customerMethods>, paymentMethodId) =>
savedMethods->Array.filter(savedMethod => savedMethod.paymentMethodId !== paymentMethodId)
let handleDelete = async (paymentItem: PaymentType.customerMethods) => {
messageParentWindow([
("fullscreen", true->JSON.Encode.bool),
("param", "paymentloader"->JSON.Encode.string),
("iframeId", iframeId->JSON.Encode.string),
])
try {
let res = await PaymentHelpers.deletePaymentMethod(
~ephemeralKey=config.ephemeralKey,
~paymentMethodId=paymentItem.paymentMethodId,
~logger,
~customPodUri,
)
let dict = res->getDictFromJson
let paymentMethodId = dict->getString("payment_method_id", "")
let isDeleted = dict->getBool("deleted", false)
if isDeleted {
logger.setLogInfo(
~value="Successfully Deleted Saved Payment Method",
~eventName=DELETE_SAVED_PAYMENT_METHOD,
)
setSavedMethods(prev => prev->removeSavedMethod(paymentMethodId))
} else {
logger.setLogError(~value=res->JSON.stringify, ~eventName=DELETE_SAVED_PAYMENT_METHOD)
}
} catch {
| err =>
let exceptionMessage = err->formatException->JSON.stringify
logger.setLogError(
~value=`Error Deleting Saved Payment Method: ${exceptionMessage}`,
~eventName=DELETE_SAVED_PAYMENT_METHOD,
)
}
messageParentWindow([("fullscreen", false->JSON.Encode.bool)])
}
savedMethods
->Array.mapWithIndex((obj, i) => {
let brandIcon = obj->getPaymentMethodBrand
<SavedMethodItem key={i->Int.toString} paymentItem=obj brandIcon handleDelete />
})
->React.array
}
| 501 | 10,410 |
hyperswitch-web
|
src/Components/WalletShimmer.res
|
.res
|
@react.component
let make = () => {
open PaymentElementShimmer
<Shimmer classname="opacity-70">
<div
className="animate-pulse w-full h-12 rounded bg-slate-200 flex justify-center items-center ">
<div className="w-24 h-3 rounded bg-white bg-opacity-70 self-center " />
</div>
</Shimmer>
}
| 92 | 10,411 |
hyperswitch-web
|
src/Components/PaymentField.res
|
.res
|
open RecoilAtoms
open RecoilAtomTypes
@react.component
let make = (
~setValue=?,
~value: RecoilAtomTypes.field,
~valueDropDown=?,
~setValueDropDown=?,
~dropDownFieldName=?,
~dropDownOptions=?,
~onChange,
~onBlur=?,
~rightIcon=React.null,
~fieldName="",
~name="",
~type_="text",
~paymentType: CardThemeType.mode,
~maxLength=?,
~pattern=?,
~placeholder="",
~className="",
~inputRef,
~displayValue=?,
~setDisplayValue=?,
) => {
let {config} = Recoil.useRecoilValueFromAtom(configAtom)
let {themeObj} = Recoil.useRecoilValueFromAtom(configAtom)
let {readOnly} = Recoil.useRecoilValueFromAtom(optionAtom)
let {parentURL} = Recoil.useRecoilValueFromAtom(keys)
let isSpacedInnerLayout = config.appearance.innerLayout === Spaced
let (inputFocused, setInputFocused) = React.useState(_ => false)
let handleFocus = _ => {
setInputFocused(_ => true)
switch setValue {
| Some(fn) =>
fn(prev => {
...prev,
isValid: None,
errorString: "",
})
| None => ()
}
Utils.handleOnFocusPostMessage(~targetOrigin=parentURL)
}
let handleBlur = ev => {
setInputFocused(_ => false)
switch onBlur {
| Some(fn) => fn(ev)
| None => ()
}
Utils.handleOnBlurPostMessage(~targetOrigin=parentURL)
}
let backgroundClass = switch paymentType {
| Payment => themeObj.colorBackground
| _ => "transparent"
}
let direction = if type_ == "password" || type_ == "tel" {
"ltr"
} else {
""
}
let focusClass = if inputFocused || value.value->String.length > 0 {
`mb-7 pb-1 pt-2 ${themeObj.fontSizeXs} transition-all ease-in duration-75`
} else {
"transition-all ease-in duration-75"
}
let floatinglabelClass = inputFocused ? "Label--floating" : "Label--resting"
let getClassName = initialLabel => {
if value.value->String.length == 0 {
`${initialLabel}--empty`
} else {
switch value.isValid {
| Some(valid) => valid ? "" : `${initialLabel}--invalid`
| None => ""
}
}
}
let labelClass = getClassName("Label")
let inputClass = getClassName("Input")
let inputClassStyles = isSpacedInnerLayout ? "Input" : "Input-Compressed"
let flexDirectionBasedOnType = type_ === "tel" ? "flex-row" : "flex-col"
<div className="flex flex-col w-full">
<RenderIf
condition={name === "phone" &&
fieldName->String.length > 0 &&
config.appearance.labels == Above &&
isSpacedInnerLayout}>
<div
className={`Label ${labelClass}`}
style={
fontWeight: themeObj.fontWeightNormal,
fontSize: themeObj.fontSizeLg,
marginBottom: "5px",
opacity: "0.6",
}
ariaHidden=true>
{React.string(fieldName)}
</div>
</RenderIf>
<div className={`flex ${flexDirectionBasedOnType} w-full`} style={color: themeObj.colorText}>
<RenderIf condition={type_ === "tel"}>
<DropdownField
appearance=config.appearance
value={valueDropDown->Option.getOr("")}
setValue={setValueDropDown->Option.getOr(_ => ())}
fieldName={dropDownFieldName->Option.getOr("")}
options={dropDownOptions->Option.getOr([])}
width="w-40 mr-2"
displayValue={displayValue->Option.getOr("")}
setDisplayValue={setDisplayValue->Option.getOr(_ => ())}
isDisplayValueVisible=true
/>
</RenderIf>
<RenderIf
condition={name !== "phone" &&
fieldName->String.length > 0 &&
config.appearance.labels == Above &&
isSpacedInnerLayout}>
<div
className={`Label ${labelClass}`}
style={
fontWeight: themeObj.fontWeightNormal,
fontSize: themeObj.fontSizeLg,
marginBottom: "5px",
opacity: "0.6",
}
ariaHidden=true>
{React.string(fieldName)}
</div>
</RenderIf>
<div className="flex flex-row w-full" style={direction: direction}>
<div className="relative w-full">
<input
style={
background: backgroundClass,
padding: themeObj.spacingUnit,
width: "100%",
}
disabled=readOnly
ref={inputRef->ReactDOM.Ref.domRef}
type_
name
?maxLength
?pattern
className={`${inputClassStyles} ${inputClass} ${className} focus:outline-none transition-shadow ease-out duration-200`}
placeholder={config.appearance.labels == Above || config.appearance.labels == Never
? placeholder
: ""}
value={value.value}
autoComplete="on"
onChange
onBlur=handleBlur
onFocus=handleFocus
ariaLabel={`Type to fill ${fieldName->String.length > 0 ? fieldName : name} input`}
/>
<RenderIf condition={config.appearance.labels == Floating}>
<div
className={`Label ${floatinglabelClass} ${labelClass} absolute bottom-0 ml-3 ${focusClass}`}
style={
marginBottom: {
inputFocused || value.value->String.length > 0 ? "" : themeObj.spacingUnit
},
fontSize: {
inputFocused || value.value->String.length > 0 ? themeObj.fontSizeXs : ""
},
opacity: "0.6",
}
ariaHidden=true>
{React.string(fieldName)}
</div>
</RenderIf>
</div>
<div className={`relative flex -ml-10 items-center`}> {rightIcon} </div>
</div>
<RenderIf condition={value.errorString->String.length > 0}>
<div
className="Error pt-1"
style={
color: themeObj.colorDangerText,
fontSize: themeObj.fontSizeSm,
alignSelf: "start",
textAlign: "left",
}
ariaHidden=true>
{React.string(value.errorString)}
</div>
</RenderIf>
</div>
</div>
}
| 1,453 | 10,412 |
hyperswitch-web
|
src/Components/PaymentDropDownField.res
|
.res
|
open RecoilAtoms
@react.component
let make = (
~value: RecoilAtomTypes.field,
~setValue: (RecoilAtomTypes.field => RecoilAtomTypes.field) => unit,
~fieldName,
~options,
~disabled=false,
~className="",
) => {
let {config} = Recoil.useRecoilValueFromAtom(configAtom)
let {themeObj, localeString} = Recoil.useRecoilValueFromAtom(configAtom)
let {readOnly} = Recoil.useRecoilValueFromAtom(optionAtom)
let dropdownRef = React.useRef(Nullable.null)
let (inputFocused, setInputFocused) = React.useState(_ => false)
let {parentURL} = Recoil.useRecoilValueFromAtom(keys)
let isSpacedInnerLayout = config.appearance.innerLayout === Spaced
let getClassName = initialLabel => {
if value.value->String.length == 0 {
`${initialLabel}--empty`
} else {
switch value.isValid {
| Some(valid) => valid ? "" : `${initialLabel}--invalid`
| None => ""
}
}
}
React.useEffect(() => {
let initialValue = options->Array.get(0)->Option.getOr("")
if value.value === "" || options->Array.includes(value.value)->not {
setValue(_ => {
errorString: "",
isValid: Some(true),
value: initialValue,
})
}
None
}, [options])
let handleFocus = _ => {
setInputFocused(_ => true)
Utils.handleOnFocusPostMessage(~targetOrigin=parentURL)
}
let focusClass = if inputFocused || value.value->String.length > 0 {
`mb-7 pb-1 pt-2 ${themeObj.fontSizeXs} transition-all ease-in duration-75`
} else {
"transition-all ease-in duration-75"
}
let floatinglabelClass = inputFocused ? "Label--floating" : "Label--resting"
let labelClass = getClassName("Label")
let inputClass = getClassName("Input")
let inputClassStyles = isSpacedInnerLayout ? "Input" : "Input-Compressed"
let handleChange = ev => {
let target = ev->ReactEvent.Form.target
let value = target["value"]
setValue(_ => {
isValid: Some(true),
value,
errorString: "",
})
}
let disbaledBG = React.useMemo(() => {
themeObj.colorBackground
}, [themeObj])
let cursorClass = !disabled ? "cursor-pointer" : "cursor-not-allowed"
<RenderIf condition={options->Array.length > 0}>
<div className="flex flex-col w-full" style={color: themeObj.colorText}>
<RenderIf
condition={fieldName->String.length > 0 &&
config.appearance.labels == Above &&
isSpacedInnerLayout}>
<div
className={`Label ${labelClass} `}
style={
fontWeight: themeObj.fontWeightNormal,
fontSize: themeObj.fontSizeLg,
marginBottom: "5px",
opacity: "0.6",
}
ariaHidden=true>
{React.string(fieldName)}
</div>
</RenderIf>
<div className="relative">
<select
ref={dropdownRef->ReactDOM.Ref.domRef}
style={
background: disabled ? disbaledBG : themeObj.colorBackground,
opacity: disabled ? "35%" : "",
padding: "11px 22px 11px 11px",
width: "100%",
}
name=""
value=value.value
disabled={readOnly || disabled}
onFocus={handleFocus}
onChange=handleChange
className={`${inputClassStyles} ${inputClass} ${className} w-full appearance-none outline-none overflow-hidden whitespace-nowrap text-ellipsis ${cursorClass}`}
ariaLabel={`${fieldName} option tab`}>
{options
->Array.mapWithIndex((item: string, i) => {
<option key={Int.toString(i)} value=item> {React.string(item)} </option>
})
->React.array}
</select>
<RenderIf condition={config.appearance.labels == Floating}>
<div
className={`Label ${floatinglabelClass} ${labelClass} absolute bottom-0 ml-3 ${focusClass}`}
style={
marginBottom: {
inputFocused || value.value->String.length > 0 ? "" : themeObj.spacingUnit
},
fontSize: {
inputFocused || value.value->String.length > 0 ? themeObj.fontSizeXs : ""
},
opacity: "0.6",
}
ariaHidden=true>
{React.string(fieldName)}
</div>
</RenderIf>
<div
className="self-center absolute"
style={
opacity: disabled ? "35%" : "",
color: themeObj.colorText,
left: localeString.localeDirection == "rtl" ? "1%" : "97%",
top: "42%",
marginLeft: localeString.localeDirection == "rtl" ? "1rem" : "-1rem",
}>
<Icon size=10 name={"arrow-down"} />
</div>
<RenderIf condition={value.errorString->String.length > 0}>
<div
className="Error pt-1"
style={
color: themeObj.colorDangerText,
fontSize: themeObj.fontSizeSm,
alignSelf: "start",
textAlign: "left",
}>
{React.string(value.errorString)}
</div>
</RenderIf>
</div>
</div>
</RenderIf>
}
| 1,220 | 10,413 |
hyperswitch-web
|
src/Components/DropdownField.res
|
.res
|
type optionType = {
value: string,
label?: string,
displayValue?: string,
}
let updateArrayOfStringToOptionsTypeArray = arrayOfString =>
arrayOfString->Array.map(item => {
value: item,
})
let defaultValue = {
value: "",
}
open RecoilAtoms
@react.component
let make = (
~appearance: CardThemeType.appearance,
~value,
~setValue,
~isDisplayValueVisible=false,
~displayValue=?,
~setDisplayValue=?,
~fieldName,
~options: array<optionType>,
~disabled=false,
~className="",
~width="w-full",
) => {
let {themeObj, localeString, config} = Recoil.useRecoilValueFromAtom(configAtom)
let {readOnly} = Recoil.useRecoilValueFromAtom(optionAtom)
let dropdownRef = React.useRef(Nullable.null)
let (inputFocused, setInputFocused) = React.useState(_ => false)
let {parentURL} = Recoil.useRecoilValueFromAtom(keys)
let isSpacedInnerLayout = config.appearance.innerLayout === Spaced
let handleFocus = _ => {
setInputFocused(_ => true)
Utils.handleOnFocusPostMessage(~targetOrigin=parentURL)
}
let handleChange = ev => {
let target = ev->ReactEvent.Form.target
let value = target["value"]
setValue(_ => value)
if isDisplayValueVisible {
let findDisplayValue =
options
->Array.find(ele => ele.value === value)
->Option.getOr(defaultValue)
switch setDisplayValue {
| Some(setDisplayValue) =>
setDisplayValue(_ => findDisplayValue.displayValue->Option.getOr(value))
| None => ()
}
}
}
let disbaledBG = React.useMemo(() => {
themeObj.colorBackground
}, [themeObj])
React.useEffect0(() => {
if value === "" || !(options->Array.map(val => val.value)->Array.includes(value)) {
setValue(_ =>
(
options
->Array.get(0)
->Option.getOr(defaultValue)
).value
)
}
None
})
let focusClass = if inputFocused || value->String.length > 0 {
`mb-7 pb-1 pt-2 ${themeObj.fontSizeXs} transition-all ease-in duration-75`
} else {
"transition-all ease-in duration-75"
}
let floatinglabelClass = inputFocused ? "Label--floating" : "Label--resting"
let inputClassStyles = isSpacedInnerLayout ? "Input" : "Input-Compressed"
let cursorClass = !disabled ? "cursor-pointer" : "cursor-not-allowed"
<RenderIf condition={options->Array.length > 0}>
<div className={`flex flex-col ${width}`}>
<RenderIf
condition={fieldName->String.length > 0 &&
appearance.labels == Above &&
isSpacedInnerLayout}>
<div
className={`Label `}
style={
fontWeight: themeObj.fontWeightNormal,
fontSize: themeObj.fontSizeLg,
marginBottom: "5px",
opacity: "0.6",
}
ariaHidden=true>
{React.string(fieldName)}
</div>
</RenderIf>
<div className="relative">
<RenderIf condition={isDisplayValueVisible && displayValue->Option.isSome}>
<div
className="absolute top-[2px] left-[2px] right-0 bottom-[2px] pointer-events-none rounded-sm z-20 whitespace-nowrap"
style={
background: disabled ? disbaledBG : themeObj.colorBackground,
opacity: disabled ? "35%" : "",
padding: themeObj.spacingUnit,
width: "calc(100% - 22px)",
}
ariaHidden=true>
{React.string(displayValue->Option.getOr(""))}
</div>
</RenderIf>
<select
ref={dropdownRef->ReactDOM.Ref.domRef}
style={
background: disabled ? disbaledBG : themeObj.colorBackground,
opacity: disabled ? "35%" : "",
padding: themeObj.spacingUnit,
paddingRight: "22px",
width: "100%",
}
name=""
value
disabled={readOnly || disabled}
onChange=handleChange
onFocus=handleFocus
className={`${inputClassStyles} ${className} w-full appearance-none outline-none overflow-hidden whitespace-nowrap text-ellipsis ${cursorClass}`}
ariaLabel={`${fieldName} option tab`}>
{options
->Array.mapWithIndex((item, index) => {
<option key={Int.toString(index)} value=item.value>
{React.string(item.label->Option.getOr(item.value))}
</option>
})
->React.array}
</select>
<RenderIf condition={config.appearance.labels == Floating}>
<div
className={`Label ${floatinglabelClass} absolute bottom-0 ml-3 ${focusClass}`}
style={
marginBottom: {
inputFocused || value->String.length > 0 ? "" : themeObj.spacingUnit
},
fontSize: {
inputFocused || value->String.length > 0 ? themeObj.fontSizeXs : ""
},
opacity: "0.6",
}
ariaHidden=true>
{React.string(fieldName)}
</div>
</RenderIf>
<div
className="self-center absolute pointer-events-none"
style={
opacity: disabled ? "35%" : "",
color: themeObj.colorText,
left: localeString.localeDirection == "rtl" ? "1%" : "97%",
top: "42%",
marginLeft: localeString.localeDirection == "rtl" ? "1rem" : "-1rem",
}>
<Icon size=10 name={"arrow-down"} />
</div>
</div>
</div>
</RenderIf>
}
| 1,292 | 10,414 |
hyperswitch-web
|
src/Components/SavedCardItem.res
|
.res
|
module RenderSavedPaymentMethodItem = {
@react.component
let make = (~paymentItem: PaymentType.customerMethods, ~paymentMethodType) => {
switch paymentItem.paymentMethod {
| "card" =>
<div
className="flex flex-col items-start"
role="group"
ariaLabel={`Card ${paymentItem.card.nickname}, ending in ${paymentItem.card.last4Digits}`}>
<div className="text-base tracking-wide">
{React.string(
paymentItem.card.nickname->String.length > 15
? paymentItem.card.nickname->String.slice(~start=0, ~end=13)->String.concat("..")
: paymentItem.card.nickname,
)}
</div>
<div className={`PickerItemLabel flex flex-row gap-3 items-center text-sm`}>
<div className="tracking-widest" ariaHidden=true> {React.string(`****`)} </div>
<div className="tracking-wide" ariaHidden=true>
{React.string(paymentItem.card.last4Digits)}
</div>
</div>
</div>
| "bank_debit" =>
<div
className="flex flex-col items-start"
role="group"
ariaLabel={`${paymentMethodType->String.toUpperCase} bank debit account ending in ${paymentItem.bank.mask}`}>
<div>
{React.string(
`${paymentMethodType->String.toUpperCase} ${paymentItem.paymentMethod->Utils.snakeToTitleCase}`,
)}
</div>
<div className={`PickerItemLabel flex flex-row gap-3 items-center`}>
<div className="tracking-widest" ariaHidden=true> {React.string(`****`)} </div>
<div ariaHidden=true> {React.string(paymentItem.bank.mask)} </div>
</div>
</div>
| _ =>
<div ariaLabel={paymentMethodType->Utils.snakeToTitleCase}>
{React.string(paymentMethodType->Utils.snakeToTitleCase)}
</div>
}
}
}
@react.component
let make = (
~setPaymentToken,
~isActive,
~paymentItem: PaymentType.customerMethods,
~brandIcon,
~index,
~savedCardlength,
~cvcProps,
~paymentType,
~setRequiredFieldsBody,
) => {
let {themeObj, config, localeString} = Recoil.useRecoilValueFromAtom(RecoilAtoms.configAtom)
let {
hideExpiredPaymentMethods,
displayDefaultSavedPaymentIcon,
displayBillingDetails,
} = Recoil.useRecoilValueFromAtom(RecoilAtoms.optionAtom)
let (cardBrand, setCardBrand) = Recoil.useRecoilState(RecoilAtoms.cardBrand)
let (
isCVCValid,
setIsCVCValid,
cvcNumber,
_,
changeCVCNumber,
handleCVCBlur,
_,
_,
cvcError,
_,
) = cvcProps
let cvcRef = React.useRef(Nullable.null)
let pickerItemClass = isActive ? "PickerItem--selected" : ""
let focusCVC = () => {
setCardBrand(_ =>
switch paymentItem.card.scheme {
| Some(val) => val
| None => ""
}
)
let optionalRef = cvcRef.current->Nullable.toOption
switch optionalRef {
| Some(_) => optionalRef->Option.forEach(input => input->CardUtils.focus)->ignore
| None => ()
}
}
let isCard = paymentItem.paymentMethod === "card"
let isRenderCvv = isCard && paymentItem.requiresCvv
let expiryMonth = paymentItem.card.expiryMonth
let expiryYear = paymentItem.card.expiryYear
let paymentMethodType = switch paymentItem.paymentMethodType {
| Some(paymentMethodType) => paymentMethodType
| None => "debit"
}
React.useEffect(() => {
open CardUtils
if isActive {
// * Focus CVC
focusCVC()
// * Sending card expiry to handle cases where the card expires before the use date.
`${expiryMonth}${String.substring(~start=2, ~end=4, expiryYear)}`
->formatCardExpiryNumber
->emitExpiryDate
PaymentUtils.emitPaymentMethodInfo(
~paymentMethod=paymentItem.paymentMethod,
~paymentMethodType,
~cardBrand=cardBrand->CardUtils.getCardType,
)
}
None
}, (isActive, cardBrand, paymentItem.paymentMethod, paymentMethodType))
let expiryDate = Date.fromString(`${expiryYear}-${expiryMonth}`)
expiryDate->Date.setMonth(expiryDate->Date.getMonth + 1)
let currentDate = Date.make()
let isCardExpired = isCard && expiryDate < currentDate
let billingDetailsText = "Billing Details:"
let billingDetailsArray =
[
paymentItem.billing.address.line1,
paymentItem.billing.address.line2,
paymentItem.billing.address.line3,
paymentItem.billing.address.city,
paymentItem.billing.address.state,
paymentItem.billing.address.country,
paymentItem.billing.address.zip,
]
->Array.map(item => Option.getOr(item, ""))
->Array.filter(item => String.trim(item) !== "")
let billingDetailsArrayLength = Array.length(billingDetailsArray)
let isCVCEmpty = cvcNumber->String.length == 0
let {innerLayout} = config.appearance
<RenderIf condition={!hideExpiredPaymentMethods || !isCardExpired}>
<button
className={`PickerItem ${pickerItemClass} flex flex-row items-stretch`}
type_="button"
style={
minWidth: "150px",
width: "100%",
padding: "1rem 0 1rem 0",
cursor: "pointer",
borderBottom: index == savedCardlength - 1 ? "0px" : `1px solid ${themeObj.borderColor}`,
borderTop: "none",
borderLeft: "none",
borderRight: "none",
borderRadius: "0px",
background: "transparent",
color: themeObj.colorTextSecondary,
boxShadow: "none",
opacity: {isCardExpired ? "0.7" : "1"},
}
onClick={_ => {
open RecoilAtomTypes
setPaymentToken(_ => {
paymentToken: paymentItem.paymentToken,
customerId: paymentItem.customerId,
})
}}>
<div className="w-full">
<div>
<div className="flex flex-row justify-between items-center">
<div
className={`flex flex-row justify-center items-center`}
style={columnGap: themeObj.spacingUnit}>
<div style={color: isActive ? themeObj.colorPrimary : ""}>
<Radio
checked=isActive
height="18px"
className="savedcard"
marginTop="-2px"
opacity="20%"
padding="46%"
border="1px solid currentColor"
/>
</div>
<div className={`PickerItemIcon mx-3 flex items-center `}> brandIcon </div>
<div className="flex flex-col">
<div className="flex items-center gap-4">
<RenderSavedPaymentMethodItem paymentItem={paymentItem} paymentMethodType />
<RenderIf
condition={displayDefaultSavedPaymentIcon &&
paymentItem.defaultPaymentMethodSet}>
<Icon size=16 name="checkmark" style={color: themeObj.colorPrimary} />
</RenderIf>
</div>
</div>
</div>
<RenderIf condition={isCard}>
<div
className={`flex flex-row items-center justify-end gap-3 -mt-1`}
style={fontSize: "14px", opacity: "0.5"}
ariaLabel={`Expires ${expiryMonth} / ${expiryYear->CardUtils.formatExpiryToTwoDigit}`}>
<div className="flex" ariaHidden=true>
{React.string(`${expiryMonth} / ${expiryYear->CardUtils.formatExpiryToTwoDigit}`)}
</div>
</div>
</RenderIf>
</div>
<div className="w-full">
<div className="flex flex-col items-start mx-8">
<RenderIf condition={isActive && isRenderCvv}>
<div
className={`flex flex-row items-start justify-start gap-2`}
style={fontSize: "14px", opacity: "0.5"}>
<div className="tracking-widest w-12 mt-6">
{React.string(`${localeString.cvcTextLabel}: `)}
</div>
<div
className={`flex h mx-4 justify-start w-16 ${isActive
? "opacity-1 mt-4"
: "opacity-0"}`}>
<PaymentInputField
isValid=isCVCValid
setIsValid=setIsCVCValid
value=cvcNumber
onChange=changeCVCNumber
onBlur=handleCVCBlur
errorString=""
inputFieldClassName="flex justify-start"
paymentType
appearance=config.appearance
type_="tel"
className={`tracking-widest justify-start w-full`}
maxLength=4
inputRef=cvcRef
placeholder="123"
height="1.8rem"
name={TestUtils.cardCVVInputTestId}
/>
</div>
</div>
</RenderIf>
<RenderIf
condition={isActive && displayBillingDetails && billingDetailsArrayLength > 0}>
<div className="tracking-wide text-sm text-left gap-2 mt-4 ml-2">
<div className="font-semibold"> {React.string(billingDetailsText)} </div>
<div className="font-normal">
{React.string(Array.joinWith(billingDetailsArray, ", "))}
</div>
</div>
</RenderIf>
<RenderIf
condition={isActive && isCVCEmpty && innerLayout === Spaced && cvcError != ""}>
<div
className="Error pt-1 mt-1 ml-2"
style={
color: themeObj.colorDangerText,
fontSize: themeObj.fontSizeSm,
}>
{React.string(cvcError)}
</div>
</RenderIf>
<RenderIf condition={isCardExpired}>
<div className="italic mt-3 ml-1" style={fontSize: "14px", opacity: "0.7"}>
{`*${localeString.cardExpiredText}`->React.string}
</div>
</RenderIf>
<RenderIf condition={isActive}>
<DynamicFields
paymentType
paymentMethod=paymentItem.paymentMethod
paymentMethodType
setRequiredFieldsBody
isSavedCardFlow=true
savedMethod=paymentItem
/>
<Surcharge
paymentMethod=paymentItem.paymentMethod
paymentMethodType
cardBrand={cardBrand->CardUtils.getCardType}
/>
</RenderIf>
</div>
</div>
</div>
</div>
</button>
</RenderIf>
}
| 2,409 | 10,415 |
hyperswitch-web
|
src/Components/AddressPaymentInput.res
|
.res
|
open RecoilAtoms
open PaymentType
open Utils
type addressType = Line1 | Line2 | City | Postal | State | Country
type dataModule = {states: JSON.t}
@val
external importStates: string => promise<dataModule> = "import"
let getShowType = str => {
switch str {
| "auto" => Auto
| "never" => Never
| _ => Auto
}
}
let showField = (val: PaymentType.addressType, type_: addressType) => {
switch val {
| JSONString(str) => getShowType(str)
| JSONObject(address) =>
switch type_ {
| Line1 => address.line1
| Line2 => address.line2
| City => address.city
| Postal => address.postal_code
| State => address.state
| Country => address.country
}
}
}
@react.component
let make = (~paymentType, ~className="") => {
let {localeString, themeObj} = Recoil.useRecoilValueFromAtom(configAtom)
let {fields} = Recoil.useRecoilValueFromAtom(optionAtom)
let loggerState = Recoil.useRecoilValueFromAtom(loggerAtom)
let showDetails = getShowDetails(~billingDetails=fields.billingDetails, ~logger=loggerState)
let (line1, setLine1) = Recoil.useLoggedRecoilState(userAddressline1, "line1", loggerState)
let (line2, setLine2) = Recoil.useLoggedRecoilState(userAddressline2, "line2", loggerState)
let (country, setCountry) = Recoil.useLoggedRecoilState(
userAddressCountry,
"country",
loggerState,
)
let (city, setCity) = Recoil.useLoggedRecoilState(userAddressCity, "city", loggerState)
let (postalCode, setPostalCode) = Recoil.useLoggedRecoilState(
userAddressPincode,
"postal_code",
loggerState,
)
let (state, setState) = Recoil.useLoggedRecoilState(userAddressState, "state", loggerState)
let line1Ref = React.useRef(Nullable.null)
let line2Ref = React.useRef(Nullable.null)
let cityRef = React.useRef(Nullable.null)
let postalRef = React.useRef(Nullable.null)
let (stateJson, setStatesJson) = React.useState(_ => None)
let (showOtherFileds, setShowOtherFields) = React.useState(_ => false)
let countryNames = getCountryNames(Country.country)
let checkPostalValidity = (
postal: RecoilAtomTypes.field,
setPostal: (RecoilAtomTypes.field => RecoilAtomTypes.field) => unit,
) => {
if postal.value !== "" {
setPostal(prev => {
...prev,
isValid: Some(true),
errorString: "",
})
} else {
setPostal(prev => {
...prev,
isValid: Some(false),
errorString: localeString.postalCodeInvalidText,
})
}
}
React.useEffect0(() => {
open Promise
importStates("./../States.json")
->then(res => {
setStatesJson(_ => Some(res.states))
resolve()
})
->catch(_ => {
setStatesJson(_ => None)
resolve()
})
->ignore
None
})
let onPostalChange = ev => {
let val = ReactEvent.Form.target(ev)["value"]
setPostalCode(prev => {
...prev,
value: val,
errorString: "",
})
}
let onPostalBlur = ev => {
let val = ReactEvent.Focus.target(ev)["value"]
if val !== "" {
setPostalCode(prev => {
...prev,
isValid: Some(true),
errorString: "",
})
} else {
setPostalCode(prev => {
...prev,
isValid: Some(false),
errorString: localeString.postalCodeInvalidText,
})
}
}
React.useEffect(() => {
checkPostalValidity(postalCode, setPostalCode)
None
}, country.value)
React.useEffect(() => {
setState(prev => {
...prev,
value: "",
})
None
}, [country.value])
let submitCallback = React.useCallback((ev: Window.event) => {
let json = ev.data->safeParse
let confirm = json->getDictFromJson->ConfirmType.itemToObjMapper
if confirm.doSubmit {
if line1.value == "" {
setLine1(prev => {
...prev,
errorString: localeString.line1EmptyText,
})
}
if line2.value == "" {
setLine2(prev => {
...prev,
errorString: localeString.line2EmptyText,
})
}
if state.value == "" {
setState(prev => {
...prev,
errorString: localeString.stateEmptyText,
})
}
if postalCode.value == "" {
setPostalCode(prev => {
...prev,
errorString: localeString.postalCodeEmptyText,
})
}
if city.value == "" {
setCity(prev => {
...prev,
errorString: localeString.cityEmptyText,
})
}
}
}, (line1, line2, country, state, city, postalCode))
useSubmitPaymentData(submitCallback)
let hasDefaulltValues =
line2.value !== "" || city.value !== "" || postalCode.value !== "" || state.value !== ""
<div className="flex flex-col" style={gridGap: themeObj.spacingGridColumn}>
<RenderIf condition={showField(showDetails.address, Line1) == Auto}>
<PaymentField
fieldName=localeString.line1Label
setValue={setLine1}
value=line1
onChange={ev => {
setShowOtherFields(_ => true)
setLine1(prev => {
...prev,
value: ReactEvent.Form.target(ev)["value"],
})
}}
paymentType
type_="text"
name="line1"
className
inputRef=line1Ref
placeholder=localeString.line1Placeholder
/>
</RenderIf>
<RenderIf condition={showOtherFileds || hasDefaulltValues}>
<div className="flex flex-col animate-slowShow" style={gridGap: themeObj.spacingGridColumn}>
<RenderIf condition={showField(showDetails.address, Line2) == Auto}>
<PaymentField
fieldName=localeString.line2Label
setValue={setLine2}
value=line2
onChange={ev => {
setLine2(prev => {
...prev,
value: ReactEvent.Form.target(ev)["value"],
})
}}
paymentType
type_="text"
name="line2"
className
inputRef=line2Ref
placeholder=localeString.line2Placeholder
/>
</RenderIf>
<div className="flex flex-row" style={gridGap: themeObj.spacingGridRow}>
<RenderIf condition={showField(showDetails.address, Country) == Auto}>
<PaymentDropDownField
fieldName=localeString.countryLabel
value=country
className
setValue=setCountry
options=countryNames
/>
</RenderIf>
<RenderIf condition={showField(showDetails.address, State) == Auto}>
{switch stateJson {
| Some(options) =>
<PaymentDropDownField
fieldName=localeString.stateLabel
value=state
className
setValue=setState
options={options->getStateNames(country)}
/>
| None => React.null
}}
</RenderIf>
</div>
<div className="flex flex-row" style={gridGap: themeObj.spacingGridRow}>
<RenderIf condition={showField(showDetails.address, City) == Auto}>
<PaymentField
fieldName=localeString.cityLabel
setValue={setCity}
className
value=city
onChange={ev => {
setCity(prev => {
...prev,
value: ReactEvent.Form.target(ev)["value"],
})
}}
paymentType
type_="text"
name="city"
inputRef=cityRef
placeholder=localeString.cityLabel
/>
</RenderIf>
<RenderIf condition={showField(showDetails.address, Postal) == Auto}>
<PaymentField
fieldName=localeString.postalCodeLabel
setValue={setPostalCode}
value=postalCode
onBlur=onPostalBlur
onChange=onPostalChange
paymentType
className
name="postal"
inputRef=postalRef
placeholder=localeString.postalCodeLabel
/>
</RenderIf>
</div>
</div>
</RenderIf>
</div>
}
| 1,920 | 10,416 |
hyperswitch-web
|
src/Components/BlikCodePaymentInput.res
|
.res
|
open RecoilAtoms
open Utils
@react.component
let make = () => {
let loggerState = Recoil.useRecoilValueFromAtom(loggerAtom)
let (blikCode, setblikCode) = Recoil.useLoggedRecoilState(userBlikCode, "blikCode", loggerState)
let blikCodeRef = React.useRef(Nullable.null)
let formatBSB = bsb => {
let formatted = bsb->String.replaceRegExp(%re("/\D+/g"), "")
let firstPart = formatted->CardUtils.slice(0, 3)
let secondPart = formatted->CardUtils.slice(3, 6)
if formatted->String.length <= 3 {
firstPart
} else if formatted->String.length > 3 && formatted->String.length <= 6 {
`${firstPart}-${secondPart}`
} else {
formatted
}
}
let changeblikCode = ev => {
let val: string = ReactEvent.Form.target(ev)["value"]
setblikCode(prev => {
...prev,
value: val->formatBSB,
})
}
React.useEffect(() => {
setblikCode(prev => {
...prev,
errorString: switch prev.isValid {
| Some(val) => val ? "" : "Invalid blikCode"
| None => ""
},
})
None
}, [blikCode.isValid])
let submitCallback = React.useCallback((ev: Window.event) => {
let json = ev.data->safeParse
let confirm = json->getDictFromJson->ConfirmType.itemToObjMapper
if confirm.doSubmit {
if blikCode.value == "" {
setblikCode(prev => {
...prev,
errorString: "blikCode cannot be empty",
})
}
}
}, [blikCode])
useSubmitPaymentData(submitCallback)
<RenderIf condition={true}>
<PaymentField
fieldName="Blik code"
setValue={setblikCode}
value=blikCode
onChange=changeblikCode
paymentType=Payment
type_="blikCode"
name="blikCode"
inputRef=blikCodeRef
placeholder="000 000"
maxLength=7
/>
</RenderIf>
}
| 507 | 10,417 |
hyperswitch-web
|
src/Components/NicknamePaymentInput.res
|
.res
|
@react.component
let make = (~paymentType: CardThemeType.mode) => {
open RecoilAtoms
open Utils
let (nickName, setNickName) = Recoil.useRecoilState(userCardNickName)
let {localeString} = Recoil.useRecoilValueFromAtom(configAtom)
let validateNickname = val => {
let isValid = Some(val === "" || !(val->isDigitLimitExceeded(~digit=2)))
let errorString =
val !== "" && val->isDigitLimitExceeded(~digit=2) ? localeString.invalidNickNameError : ""
(isValid, errorString)
}
let setNickNameState = (val, prevState: RecoilAtomTypes.field) => {
let (isValid, errorString) = val->validateNickname
{
...prevState,
value: val,
isValid,
errorString,
}
}
let onChange = ev => {
let val: string = ReactEvent.Form.target(ev)["value"]
setNickName(prev => setNickNameState(val, prev))
}
let onBlur = ev => {
let val: string = ReactEvent.Focus.target(ev)["value"]
setNickName(prev => setNickNameState(val, prev))
}
<PaymentField
fieldName=localeString.cardNickname
value=nickName
setValue=setNickName
onChange
onBlur
paymentType
type_="userCardNickName"
name="userCardNickName"
inputRef={React.useRef(Nullable.null)}
placeholder=localeString.nicknamePlaceholder
maxLength=12
/>
}
| 348 | 10,418 |
hyperswitch-web
|
src/Components/PaymentLoader.res
|
.res
|
@react.component
let make = () => {
open Utils
let (branding, setBranding) = React.useState(_ => "auto")
React.useEffect0(() => {
messageParentWindow([("iframeMountedCallback", true->JSON.Encode.bool)])
let handle = (ev: Window.event) => {
let json = ev.data->safeParse
let dict = json->getDictFromJson
setBranding(_ => dict->getDictFromDict("options")->getString("branding", "auto"))
}
Window.addEventListener("message", handle)
Some(() => {Window.removeEventListener("message", handle)})
})
let styles =
branding === "auto"
? "backdrop-blur-md bg-black/80"
: "backdrop-contrast-125 backdrop-blur-2xl opacity-70 bg-black/80"
<div className={`h-screen w-screen flex m-auto items-center ${styles}`}>
<div className={`flex flex-col justify-center m-auto visible`}>
<Loader branding />
</div>
</div>
}
| 233 | 10,419 |
hyperswitch-web
|
src/Components/DynamicFields.res
|
.res
|
module DynamicFieldsToRenderWrapper = {
@react.component
let make = (~children, ~index, ~isInside=true) => {
let {themeObj} = Recoil.useRecoilValueFromAtom(RecoilAtoms.configAtom)
<RenderIf condition={children != React.null}>
<div
key={`${isInside ? "inside" : "outside"}-billing-${index->Int.toString}`}
className="flex flex-col w-full place-content-between"
style={
gridColumnGap: isInside ? "0px" : themeObj.spacingGridRow,
}>
{children}
</div>
</RenderIf>
}
}
@react.component
let make = (
~paymentType,
~paymentMethod,
~paymentMethodType,
~setRequiredFieldsBody,
~isSavedCardFlow=false,
~savedMethod=PaymentType.defaultCustomerMethods,
~cardProps=None,
~expiryProps=None,
~cvcProps=None,
~isBancontact=false,
~isSaveDetailsWithClickToPay=false,
) => {
open DynamicFieldsUtils
open Utils
open RecoilAtoms
let paymentMethodListValue = Recoil.useRecoilValueFromAtom(PaymentUtils.paymentMethodListValue)
React.useEffect(() => {
setRequiredFieldsBody(_ => Dict.make())
None
}, [paymentMethodType])
let {billingAddress} = Recoil.useRecoilValueFromAtom(optionAtom)
//<...>//
let paymentMethodTypes = PaymentUtils.usePaymentMethodTypeFromList(
~paymentMethodListValue,
~paymentMethod,
~paymentMethodType,
)
let creditPaymentMethodTypes = PaymentUtils.usePaymentMethodTypeFromList(
~paymentMethodListValue,
~paymentMethod,
~paymentMethodType="credit",
)
let requiredFieldsWithBillingDetails = React.useMemo(() => {
if paymentMethod === "card" {
let creditRequiredFields = creditPaymentMethodTypes.required_fields
[
...paymentMethodTypes.required_fields,
...creditRequiredFields,
]->removeRequiredFieldsDuplicates
} else if dynamicFieldsEnabledPaymentMethods->Array.includes(paymentMethodType) {
paymentMethodTypes.required_fields
} else {
[]
}
}, (
paymentMethod,
paymentMethodTypes.required_fields,
paymentMethodType,
creditPaymentMethodTypes.required_fields,
))
let requiredFields = React.useMemo(() => {
requiredFieldsWithBillingDetails
->removeBillingDetailsIfUseBillingAddress(billingAddress)
->removeClickToPayFieldsIfSaveDetailsWithClickToPay(isSaveDetailsWithClickToPay)
}, (requiredFieldsWithBillingDetails, isSaveDetailsWithClickToPay))
let isAllStoredCardsHaveName = React.useMemo(() => {
PaymentType.getIsStoredPaymentMethodHasName(savedMethod)
}, [savedMethod])
//<...>//
let fieldsArr = React.useMemo(() => {
PaymentMethodsRecord.getPaymentMethodFields(
paymentMethodType,
requiredFields,
~isSavedCardFlow,
~isAllStoredCardsHaveName,
)
->updateDynamicFields(billingAddress, isSaveDetailsWithClickToPay)
->Belt.SortArray.stableSortBy(PaymentMethodsRecord.sortPaymentMethodFields)
//<...>//
}, (requiredFields, isAllStoredCardsHaveName, isSavedCardFlow, isSaveDetailsWithClickToPay))
let {config, themeObj, localeString} = Recoil.useRecoilValueFromAtom(configAtom)
let isSpacedInnerLayout = config.appearance.innerLayout === Spaced
let logger = Recoil.useRecoilValueFromAtom(loggerAtom)
let (line1, setLine1) = Recoil.useLoggedRecoilState(userAddressline1, "line1", logger)
let (line2, setLine2) = Recoil.useLoggedRecoilState(userAddressline2, "line2", logger)
let (city, setCity) = Recoil.useLoggedRecoilState(userAddressCity, "city", logger)
let (state, setState) = Recoil.useLoggedRecoilState(userAddressState, "state", logger)
let (postalCode, setPostalCode) = Recoil.useLoggedRecoilState(
userAddressPincode,
"postal_code",
logger,
)
let (currency, setCurrency) = Recoil.useLoggedRecoilState(userCurrency, "currency", logger)
let line1Ref = React.useRef(Nullable.null)
let line2Ref = React.useRef(Nullable.null)
let cityRef = React.useRef(Nullable.null)
let bankAccountNumberRef = React.useRef(Nullable.null)
let postalRef = React.useRef(Nullable.null)
let (selectedBank, setSelectedBank) = Recoil.useRecoilState(userBank)
let (country, setCountry) = Recoil.useRecoilState(userCountry)
let (bankAccountNumber, setBankAccountNumber) = Recoil.useLoggedRecoilState(
userBankAccountNumber,
"bankAccountNumber",
logger,
)
let defaultCardProps = (
None,
_ => (),
None,
"",
_ => (),
_ => (),
React.useRef(Nullable.null),
React.null,
"",
_ => (),
0,
"",
)
let defaultExpiryProps = (
None,
_ => (),
"",
_ => (),
_ => (),
React.useRef(Nullable.null),
_ => (),
"",
_ => (),
)
let defaultCvcProps = (
None,
_ => (),
"",
_ => (),
_ => (),
_ => (),
React.useRef(Nullable.null),
_ => (),
"",
_ => (),
)
let (stateJson, setStatesJson) = React.useState(_ => None)
let bankNames = Bank.getBanks(paymentMethodType)->getBankNames(paymentMethodTypes.bank_names)
let countryNames = getCountryNames(Country.getCountry(paymentMethodType))
let setCurrency = val => {
setCurrency(val)
}
let setSelectedBank = val => {
setSelectedBank(val)
}
let setCountry = val => {
setCountry(val)
}
let (
isCardValid,
setIsCardValid,
_,
cardNumber,
changeCardNumber,
handleCardBlur,
cardRef,
icon,
cardError,
_,
maxCardLength,
_,
) = switch cardProps {
| Some(cardProps) => cardProps
| None => defaultCardProps
}
let (
isExpiryValid,
setIsExpiryValid,
cardExpiry,
changeCardExpiry,
handleExpiryBlur,
expiryRef,
_,
expiryError,
_,
) = switch expiryProps {
| Some(expiryProps) => expiryProps
| None => defaultExpiryProps
}
let (
isCVCValid,
setIsCVCValid,
cvcNumber,
_,
changeCVCNumber,
handleCVCBlur,
cvcRef,
_,
cvcError,
_,
) = switch cvcProps {
| Some(cvcProps) => cvcProps
| None => defaultCvcProps
}
let isCvcValidValue = CardUtils.getBoolOptionVal(isCVCValid)
let (cardEmpty, cardComplete, cardInvalid) = CardUtils.useCardDetails(
~cvcNumber,
~isCVCValid,
~isCvcValidValue,
)
React.useEffect0(() => {
let bank = bankNames->Array.get(0)->Option.getOr("")
setSelectedBank(_ => bank)
None
})
React.useEffect0(() => {
open Promise
AddressPaymentInput.importStates("./../States.json")
->then(res => {
setStatesJson(_ => Some(res.states))
resolve()
})
->catch(_ => {
setStatesJson(_ => None)
resolve()
})
->ignore
None
})
let onPostalChange = ev => {
let val = ReactEvent.Form.target(ev)["value"]
if val !== "" {
setPostalCode(_ => {
isValid: Some(true),
value: val,
errorString: "",
})
} else {
setPostalCode(_ => {
isValid: Some(false),
value: val,
errorString: "",
})
}
}
useRequiredFieldsEmptyAndValid(
~requiredFields,
~fieldsArr,
~countryNames,
~bankNames,
~isCardValid,
~isExpiryValid,
~isCVCValid,
~cardNumber,
~cardExpiry,
~cvcNumber,
~isSavedCardFlow,
)
useSetInitialRequiredFields(
~requiredFields={
billingAddress.usePrefilledValues === Auto ? requiredFieldsWithBillingDetails : requiredFields
},
~paymentMethodType,
)
useRequiredFieldsBody(
~requiredFields,
~paymentMethodType,
~cardNumber,
~cardExpiry,
~cvcNumber,
~isSavedCardFlow,
~isAllStoredCardsHaveName,
~setRequiredFieldsBody,
)
let submitCallback = useSubmitCallback()
useSubmitPaymentData(submitCallback)
let bottomElement = <InfoElement />
let getCustomFieldName = (item: PaymentMethodsRecord.paymentMethodsFields) => {
if (
requiredFields
->Array.filter(requiredFieldType =>
requiredFieldType.field_type === item &&
requiredFieldType.display_name === "card_holder_name"
)
->Array.length > 0
) {
Some(localeString.cardHolderName)
} else {
None
}
}
let dynamicFieldsToRenderOutsideBilling = React.useMemo(() => {
fieldsArr->Array.filter(isFieldTypeToRenderOutsideBilling)
}, [fieldsArr])
let dynamicFieldsToRenderInsideBilling = React.useMemo(() => {
fieldsArr->Array.filter(field => !(field->isFieldTypeToRenderOutsideBilling))
}, [fieldsArr])
let isInfoElementPresent = dynamicFieldsToRenderInsideBilling->Array.includes(InfoElement)
let isOnlyInfoElementPresent =
dynamicFieldsToRenderInsideBilling->Array.length === 1 && isInfoElementPresent
let isRenderDynamicFieldsInsideBilling =
dynamicFieldsToRenderInsideBilling->Array.length > 0 &&
(dynamicFieldsToRenderInsideBilling->Array.length > 1 || !isOnlyInfoElementPresent)
let spacedStylesForBiilingDetails = isSpacedInnerLayout ? "p-2" : "my-2"
<RenderIf condition={!isSavedCardFlow && fieldsArr->Array.length > 0}>
{<>
{dynamicFieldsToRenderOutsideBilling
->Array.mapWithIndex((item, index) => {
<DynamicFieldsToRenderWrapper key={index->Int.toString} index={index} isInside={false}>
{switch item {
| CardNumber =>
<PaymentInputField
fieldName=localeString.cardNumberLabel
isValid=isCardValid
setIsValid=setIsCardValid
value=cardNumber
onChange=changeCardNumber
onBlur=handleCardBlur
rightIcon={icon}
errorString=cardError
paymentType
type_="tel"
appearance=config.appearance
maxLength=maxCardLength
inputRef=cardRef
placeholder="1234 1234 1234 1234"
/>
| CardExpiryMonth
| CardExpiryYear
| CardExpiryMonthAndYear =>
<PaymentInputField
fieldName=localeString.validThruText
isValid=isExpiryValid
setIsValid=setIsExpiryValid
value=cardExpiry
onChange=changeCardExpiry
onBlur=handleExpiryBlur
errorString=expiryError
paymentType
type_="tel"
appearance=config.appearance
maxLength=7
inputRef=expiryRef
placeholder=localeString.expiryPlaceholder
/>
| CardCvc =>
<PaymentInputField
fieldName=localeString.cvcTextLabel
isValid=isCVCValid
setIsValid=setIsCVCValid
value=cvcNumber
onChange=changeCVCNumber
onBlur=handleCVCBlur
errorString=cvcError
paymentType
rightIcon={CardUtils.setRightIconForCvc(
~cardEmpty,
~cardInvalid,
~color=themeObj.colorIconCardCvcError,
~cardComplete,
)}
appearance=config.appearance
type_="tel"
className="tracking-widest w-full"
maxLength=4
inputRef=cvcRef
placeholder="123"
/>
| CardExpiryAndCvc =>
<div className="flex gap-10">
<PaymentInputField
fieldName=localeString.validThruText
isValid=isExpiryValid
setIsValid=setIsExpiryValid
value=cardExpiry
onChange=changeCardExpiry
onBlur=handleExpiryBlur
errorString=expiryError
paymentType
type_="tel"
appearance=config.appearance
maxLength=7
inputRef=expiryRef
placeholder=localeString.expiryPlaceholder
/>
<PaymentInputField
fieldName=localeString.cvcTextLabel
isValid=isCVCValid
setIsValid=setIsCVCValid
value=cvcNumber
onChange=changeCVCNumber
onBlur=handleCVCBlur
errorString=cvcError
paymentType
rightIcon={CardUtils.setRightIconForCvc(
~cardEmpty,
~cardInvalid,
~color=themeObj.colorIconCardCvcError,
~cardComplete,
)}
appearance=config.appearance
type_="tel"
className="tracking-widest w-full"
maxLength=4
inputRef=cvcRef
placeholder="123"
/>
</div>
| Currency(currencyArr) =>
let updatedCurrencyArray =
currencyArr->DropdownField.updateArrayOfStringToOptionsTypeArray
<DropdownField
appearance=config.appearance
fieldName=localeString.currencyLabel
value=currency
setValue=setCurrency
disabled=false
options=updatedCurrencyArray
/>
| FullName =>
<>
<RenderIf condition={!isSpacedInnerLayout}>
<div
style={
marginBottom: "5px",
fontSize: themeObj.fontSizeLg,
opacity: "0.6",
}>
{item->getCustomFieldName->Option.getOr("")->React.string}
</div>
</RenderIf>
<FullNamePaymentInput
paymentType
customFieldName={item->getCustomFieldName}
optionalRequiredFields={Some(requiredFields)}
/>
</>
| CryptoCurrencyNetworks => <CryptoCurrencyNetworks />
| DateOfBirth => <DateOfBirth />
| VpaId => <VpaIdPaymentInput paymentType />
| PixKey => <PixPaymentInput label="pixKey" />
| PixCPF => <PixPaymentInput label="pixCPF" />
| PixCNPJ => <PixPaymentInput label="pixCNPJ" />
| BankAccountNumber | IBAN =>
<PaymentField
fieldName="IBAN"
setValue={setBankAccountNumber}
value=bankAccountNumber
onChange={ev => {
let value = ReactEvent.Form.target(ev)["value"]
setBankAccountNumber(_ => {
isValid: Some(value !== ""),
value,
errorString: value !== "" ? "" : localeString.ibanEmptyText,
})
}}
onBlur={ev => {
let value = ReactEvent.Focus.target(ev)["value"]
setBankAccountNumber(prev => {
...prev,
errorString: value !== "" ? "" : localeString.ibanEmptyText,
isValid: Some(value !== ""),
})
}}
paymentType
type_="text"
name="bankAccountNumber"
maxLength=42
inputRef=bankAccountNumberRef
placeholder="DE00 0000 0000 0000 0000 00"
/>
| Email
| InfoElement
| Country
| Bank
| None
| BillingName
| PhoneNumber
| AddressLine1
| AddressLine2
| AddressCity
| StateAndCity
| AddressPincode
| AddressState
| BlikCode
| SpecialField(_)
| CountryAndPincode(_)
| AddressCountry(_)
| ShippingName // Shipping Details are currently supported by only one click widgets
| ShippingAddressLine1
| ShippingAddressLine2
| ShippingAddressCity
| ShippingAddressPincode
| ShippingAddressState
| PhoneCountryCode
| LanguagePreference(_)
| ShippingAddressCountry(_) => React.null
}}
</DynamicFieldsToRenderWrapper>
})
->React.array}
<RenderIf condition={isRenderDynamicFieldsInsideBilling}>
<div
className={`billing-section ${spacedStylesForBiilingDetails} w-full text-left`}
style={
border: {isSpacedInnerLayout ? `1px solid ${themeObj.borderColor}` : ""},
borderRadius: {isSpacedInnerLayout ? themeObj.borderRadius : ""},
}>
<div
className="billing-details-text"
style={
marginBottom: "5px",
fontSize: themeObj.fontSizeLg,
opacity: "0.6",
}>
{React.string(localeString.billingDetailsText)}
</div>
<div
className={`flex flex-col`}
style={
gap: isSpacedInnerLayout ? themeObj.spacingGridRow : "",
}>
{dynamicFieldsToRenderInsideBilling
->Array.mapWithIndex((item, index) => {
<DynamicFieldsToRenderWrapper key={index->Int.toString} index={index}>
{switch item {
| BillingName => <BillingNamePaymentInput paymentType requiredFields />
| Email => <EmailPaymentInput paymentType />
| PhoneNumber => <PhoneNumberPaymentInput />
| StateAndCity =>
<div className={`flex ${isSpacedInnerLayout ? "gap-4" : ""} overflow-hidden`}>
<PaymentField
fieldName=localeString.cityLabel
setValue={setCity}
value=city
onChange={ev => {
let value = ReactEvent.Form.target(ev)["value"]
setCity(prev => {
isValid: Some(value !== ""),
value,
errorString: value !== "" ? "" : prev.errorString,
})
}}
onBlur={ev => {
let value = ReactEvent.Focus.target(ev)["value"]
setCity(prev => {
...prev,
isValid: Some(value !== ""),
})
}}
paymentType
type_="text"
name="city"
inputRef=cityRef
placeholder=localeString.cityLabel
className={isSpacedInnerLayout ? "" : "!border-r-0"}
/>
{switch stateJson {
| Some(options) =>
<PaymentDropDownField
fieldName=localeString.stateLabel
value=state
setValue=setState
options={options->getStateNames({
value: country,
isValid: None,
errorString: "",
})}
/>
| None => React.null
}}
</div>
| CountryAndPincode(countryArr) =>
let updatedCountryArray =
countryArr->DropdownField.updateArrayOfStringToOptionsTypeArray
<div className={`flex ${isSpacedInnerLayout ? "gap-4" : ""}`}>
<DropdownField
appearance=config.appearance
fieldName=localeString.countryLabel
value=country
setValue={setCountry}
disabled=false
options=updatedCountryArray
className={isSpacedInnerLayout ? "" : "!border-t-0 !border-r-0"}
/>
<PaymentField
fieldName=localeString.postalCodeLabel
setValue={setPostalCode}
value=postalCode
onBlur={ev => {
let value = ReactEvent.Focus.target(ev)["value"]
setPostalCode(prev => {
...prev,
isValid: Some(value !== ""),
})
}}
onChange=onPostalChange
paymentType
name="postal"
inputRef=postalRef
placeholder=localeString.postalCodeLabel
className={isSpacedInnerLayout ? "" : "!border-t-0"}
/>
</div>
| AddressLine1 =>
<PaymentField
fieldName=localeString.line1Label
setValue={setLine1}
value=line1
onChange={ev => {
let value = ReactEvent.Form.target(ev)["value"]
setLine1(prev => {
isValid: Some(value !== ""),
value,
errorString: value !== "" ? "" : prev.errorString,
})
}}
onBlur={ev => {
let value = ReactEvent.Focus.target(ev)["value"]
setLine1(prev => {
...prev,
isValid: Some(value !== ""),
})
}}
paymentType
type_="text"
name="line1"
inputRef=line1Ref
placeholder=localeString.line1Placeholder
className={isSpacedInnerLayout ? "" : "!border-b-0"}
/>
| AddressLine2 =>
<PaymentField
fieldName=localeString.line2Label
setValue={setLine2}
value=line2
onChange={ev => {
let value = ReactEvent.Form.target(ev)["value"]
setLine2(prev => {
isValid: Some(value !== ""),
value,
errorString: value !== "" ? "" : prev.errorString,
})
}}
onBlur={ev => {
let value = ReactEvent.Focus.target(ev)["value"]
setLine2(prev => {
...prev,
isValid: Some(value !== ""),
})
}}
paymentType
type_="text"
name="line2"
inputRef=line2Ref
placeholder=localeString.line2Placeholder
/>
| AddressCity =>
<PaymentField
fieldName=localeString.cityLabel
setValue={setCity}
value=city
onChange={ev => {
let value = ReactEvent.Form.target(ev)["value"]
setCity(prev => {
isValid: Some(value !== ""),
value,
errorString: value !== "" ? "" : prev.errorString,
})
}}
onBlur={ev => {
let value = ReactEvent.Focus.target(ev)["value"]
setCity(prev => {
...prev,
isValid: Some(value !== ""),
})
}}
paymentType
type_="text"
name="city"
inputRef=cityRef
placeholder=localeString.cityLabel
/>
| AddressState =>
switch stateJson {
| Some(options) =>
<PaymentDropDownField
fieldName=localeString.stateLabel
value=state
setValue=setState
options={options->getStateNames({
value: country,
isValid: None,
errorString: "",
})}
/>
| None => React.null
}
| AddressPincode =>
<PaymentField
fieldName=localeString.postalCodeLabel
setValue={setPostalCode}
value=postalCode
onBlur={ev => {
let value = ReactEvent.Focus.target(ev)["value"]
setPostalCode(prev => {
...prev,
isValid: Some(value !== ""),
})
}}
onChange=onPostalChange
paymentType
name="postal"
inputRef=postalRef
placeholder=localeString.postalCodeLabel
/>
| BlikCode => <BlikCodePaymentInput />
| Country =>
let updatedCountryNames =
countryNames->DropdownField.updateArrayOfStringToOptionsTypeArray
<DropdownField
appearance=config.appearance
fieldName=localeString.countryLabel
value=country
setValue=setCountry
disabled=false
options=updatedCountryNames
/>
| AddressCountry(countryArr) =>
let updatedCountryArr =
countryArr->DropdownField.updateArrayOfStringToOptionsTypeArray
<DropdownField
appearance=config.appearance
fieldName=localeString.countryLabel
value=country
setValue=setCountry
disabled=false
options=updatedCountryArr
/>
| Bank =>
let updatedBankNames =
bankNames->DropdownField.updateArrayOfStringToOptionsTypeArray
<DropdownField
appearance=config.appearance
fieldName=localeString.bankLabel
value=selectedBank
setValue=setSelectedBank
disabled=false
options=updatedBankNames
/>
| SpecialField(element) => element
| InfoElement =>
<>
<Surcharge paymentMethod paymentMethodType />
{if fieldsArr->Array.length > 1 {
bottomElement
} else {
<Block bottomElement />
}}
</>
| PixKey
| PixCPF
| PixCNPJ
| CardNumber
| CardExpiryMonth
| CardExpiryYear
| CardExpiryMonthAndYear
| CardCvc
| CardExpiryAndCvc
| Currency(_)
| FullName
| ShippingName // Shipping Details are currently supported by only one click widgets
| ShippingAddressLine1
| ShippingAddressLine2
| ShippingAddressCity
| ShippingAddressPincode
| ShippingAddressState
| ShippingAddressCountry(_)
| CryptoCurrencyNetworks
| DateOfBirth
| PhoneCountryCode
| VpaId
| LanguagePreference(_)
| BankAccountNumber
| IBAN
| None => React.null
}}
</DynamicFieldsToRenderWrapper>
})
->React.array}
</div>
</div>
</RenderIf>
<RenderIf condition={isOnlyInfoElementPresent}>
{<>
<Surcharge paymentMethod paymentMethodType />
{if fieldsArr->Array.length > 1 {
bottomElement
} else {
<Block bottomElement />
}}
</>}
</RenderIf>
<RenderIf condition={!isInfoElementPresent}>
<Surcharge paymentMethod paymentMethodType />
</RenderIf>
</>}
</RenderIf>
}
| 5,711 | 10,420 |
hyperswitch-web
|
src/Components/PaymentInputField.res
|
.res
|
open RecoilAtoms
@react.component
let make = (
~isValid=Some(true),
~setIsValid=?,
~height="",
~fieldWidth="100%",
~inputFieldClassName="",
~value,
~onChange,
~onBlur=?,
~rightIcon=React.null,
~errorString=?,
~fieldName="",
~name="",
~type_="text",
~paymentType: CardThemeType.mode,
~maxLength=?,
~pattern=?,
~placeholder="",
~appearance: CardThemeType.appearance,
~className="",
~inputRef,
) => {
let {themeObj, config} = Recoil.useRecoilValueFromAtom(configAtom)
let {innerLayout} = config.appearance
let {readOnly} = Recoil.useRecoilValueFromAtom(optionAtom)
let {parentURL} = Recoil.useRecoilValueFromAtom(keys)
let (inputFocused, setInputFocused) = React.useState(_ => false)
let handleFocus = _ => {
setInputFocused(_ => true)
switch setIsValid {
| Some(fn) => fn(_ => None)
| None => ()
}
Utils.handleOnFocusPostMessage(~targetOrigin=parentURL)
}
let handleBlur = ev => {
setInputFocused(_ => false)
switch onBlur {
| Some(fn) => fn(ev)
| None => ()
}
Utils.handleOnBlurPostMessage(~targetOrigin=parentURL)
}
let backgroundClass = switch paymentType {
| Payment => themeObj.colorBackground
| _ => "transparent"
}
let direction = if type_ == "password" || type_ == "tel" {
"ltr"
} else {
""
}
let focusClass = if inputFocused || value->String.length > 0 {
`mb-7 pb-1 pt-2 ${themeObj.fontSizeXs} transition-all ease-in duration-75`
} else {
"transition-all ease-in duration-75"
}
let floatinglabelClass = inputFocused ? "Label--floating" : "Label--resting"
let getClassName = initialLabel => {
if value->String.length == 0 {
`${initialLabel}--empty`
} else {
switch isValid {
| Some(valid) => valid ? "" : `${initialLabel}--invalid`
| None => ""
}
}
}
let labelClass = getClassName("Label")
let inputClass = getClassName("Input")
let inputLogoClass = getClassName("InputLogo")
let inputClassStyles = innerLayout === Spaced ? "Input" : "Input-Compressed"
<div className="flex flex-col w-full" style={color: themeObj.colorText}>
<RenderIf
condition={fieldName->String.length > 0 &&
appearance.labels == Above &&
innerLayout === Spaced}>
<div
className={`Label ${labelClass}`}
style={
fontWeight: themeObj.fontWeightNormal,
fontSize: themeObj.fontSizeLg,
marginBottom: "5px",
opacity: "0.6",
}
ariaHidden=true>
{React.string(fieldName)}
</div>
</RenderIf>
<div className="flex flex-row " style={direction: direction}>
<div className={`relative w-full ${inputFieldClassName}`}>
<input
style={
background: backgroundClass,
padding: themeObj.spacingUnit,
width: fieldWidth,
height,
}
dataTestId={name}
disabled=readOnly
ref={inputRef->ReactDOM.Ref.domRef}
type_
name
?maxLength
?pattern
className={`${inputClassStyles} ${inputClass} ${className} focus:outline-none transition-shadow ease-out duration-200`}
placeholder={appearance.labels == Above ? placeholder : ""}
value
autoComplete="on"
onChange
onBlur=handleBlur
onFocus=handleFocus
ariaLabel={`Type to fill ${fieldName->String.length > 0 ? fieldName : name} input`}
/>
<RenderIf condition={appearance.labels == Floating}>
<div
className={`Label ${floatinglabelClass} ${labelClass} absolute bottom-0 ml-3 ${focusClass} text-opacity-20 pointer-events-none`}
style={
marginBottom: {
inputFocused || value->String.length > 0 ? "" : themeObj.spacingUnit
},
fontSize: {inputFocused || value->String.length > 0 ? themeObj.fontSizeXs : ""},
opacity: "0.6",
}
ariaHidden=true>
{React.string(fieldName)}
</div>
</RenderIf>
</div>
<div className={`InputLogo ${inputLogoClass} relative flex -ml-10 items-center`}>
{rightIcon}
</div>
</div>
<RenderIf condition={innerLayout === Spaced}>
{switch errorString {
| Some(val) =>
<RenderIf condition={val->String.length > 0}>
<div
className="Error pt-1"
style={
color: themeObj.colorDangerText,
fontSize: themeObj.fontSizeSm,
alignSelf: "start",
textAlign: "left",
}>
{React.string(val)}
</div>
</RenderIf>
| None => React.null
}}
</RenderIf>
</div>
}
| 1,170 | 10,421 |
hyperswitch-web
|
src/Components/RenderIf.res
|
.res
|
@react.component
let make = (~condition: bool, ~children: React.element) => {
if condition {
children
} else {
React.null
}
}
| 38 | 10,422 |
hyperswitch-web
|
src/Components/PixPaymentInput.res
|
.res
|
@react.component
let make = (~label="") => {
open RecoilAtoms
open Utils
let {localeString} = Recoil.useRecoilValueFromAtom(configAtom)
let (pixCNPJ, setPixCNPJ) = Recoil.useRecoilState(userPixCNPJ)
let (pixCPF, setPixCPF) = Recoil.useRecoilState(userPixCPF)
let (pixKey, setPixKey) = Recoil.useRecoilState(userPixKey)
let pixKeyRef = React.useRef(Nullable.null)
let pixCPFRef = React.useRef(Nullable.null)
let pixCNPJRef = React.useRef(Nullable.null)
let changePixKey = ev => {
let val: string = ReactEvent.Form.target(ev)["value"]
setPixKey(prev => {
...prev,
value: val,
})
}
let changePixCNPJ = ev => {
let val: string = ReactEvent.Form.target(ev)["value"]
setPixCNPJ(prev => {
...prev,
value: val,
})
}
let changePixCPF = ev => {
let val: string = ReactEvent.Form.target(ev)["value"]
setPixCPF(prev => {
...prev,
value: val,
})
}
let onBlurPixKey = _ => {
if pixKey.value->String.length > 0 {
setPixKey(prev => {
...prev,
isValid: Some(true),
errorString: "",
})
} else {
setPixKey(prev => {
...prev,
isValid: None,
errorString: "",
})
}
}
let onBlurPixCNPJ = ev => {
let pixCNPJNumber = ReactEvent.Focus.target(ev)["value"]
if %re("/^\d*$/")->RegExp.test(pixCNPJNumber) && pixCNPJNumber->String.length === 14 {
setPixCNPJ(prev => {
...prev,
isValid: Some(true),
errorString: "",
})
} else if pixCNPJNumber->String.length == 0 {
setPixCNPJ(prev => {
...prev,
isValid: None,
errorString: "",
})
} else {
setPixCNPJ(prev => {
...prev,
isValid: Some(false),
errorString: localeString.pixCNPJInvalidText,
})
}
}
let onBlurPixCPF = ev => {
let pixCPFNumber = ReactEvent.Focus.target(ev)["value"]
if %re("/^\d*$/")->RegExp.test(pixCPFNumber) && pixCPFNumber->String.length === 11 {
setPixCPF(prev => {
...prev,
isValid: Some(true),
errorString: "",
})
} else if pixCPFNumber->String.length == 0 {
setPixCPF(prev => {
...prev,
isValid: None,
errorString: "",
})
} else {
setPixCPF(prev => {
...prev,
isValid: Some(false),
errorString: localeString.pixCPFInvalidText,
})
}
}
React.useEffect(() => {
if %re("/^\d*$/")->RegExp.test(pixCNPJ.value) {
setPixCNPJ(prev => {
...prev,
isValid: Some(true),
errorString: "",
})
} else {
setPixCNPJ(prev => {
...prev,
isValid: Some(false),
errorString: localeString.pixCNPJInvalidText,
})
}
None
}, [pixCNPJ.value])
React.useEffect(() => {
if %re("/^\d*$/")->RegExp.test(pixCPF.value) {
setPixCPF(prev => {
...prev,
isValid: Some(true),
errorString: "",
})
} else {
setPixCPF(prev => {
...prev,
isValid: Some(false),
errorString: localeString.pixCPFInvalidText,
})
}
None
}, [pixCPF.value])
let submitCallback = React.useCallback((ev: Window.event) => {
let json = ev.data->safeParse
let confirm = json->getDictFromJson->ConfirmType.itemToObjMapper
if confirm.doSubmit {
if pixKey.value == "" {
setPixKey(prev => {
...prev,
errorString: localeString.pixKeyEmptyText,
})
}
if pixCNPJ.value == "" {
setPixCNPJ(prev => {
...prev,
errorString: localeString.pixCNPJEmptyText,
})
}
if pixCPF.value == "" {
setPixCPF(prev => {
...prev,
errorString: localeString.pixCPFEmptyText,
})
}
}
}, [pixCNPJ.value, pixKey.value, pixCPF.value])
useSubmitPaymentData(submitCallback)
<>
<RenderIf condition={label === "pixKey"}>
<PaymentField
fieldName={localeString.pixKeyLabel}
setValue=setPixKey
value=pixKey
onChange=changePixKey
onBlur=onBlurPixKey
paymentType=Payment
type_="pixKey"
name="pixKey"
inputRef=pixKeyRef
placeholder={localeString.pixKeyPlaceholder}
/>
</RenderIf>
<RenderIf condition={label === "pixCPF"}>
<PaymentField
fieldName={localeString.pixCPFLabel}
setValue=setPixCPF
value=pixCPF
onChange=changePixCPF
onBlur=onBlurPixCPF
paymentType=Payment
type_="pixCPF"
name="pixCPF"
inputRef=pixCPFRef
placeholder={localeString.pixCPFPlaceholder}
maxLength=11
/>
</RenderIf>
<RenderIf condition={label === "pixCNPJ"}>
<PaymentField
fieldName={localeString.pixCNPJLabel}
setValue=setPixCNPJ
value=pixCNPJ
onChange=changePixCNPJ
onBlur=onBlurPixCNPJ
paymentType=Payment
type_="pixCNPJ"
name="pixCNPJ"
inputRef=pixCNPJRef
placeholder={localeString.pixCNPJPlaceholder}
maxLength=14
/>
</RenderIf>
</>
}
| 1,391 | 10,423 |
hyperswitch-web
|
src/Components/Accordion.res
|
.res
|
open RecoilAtoms
@react.component
let make = (
~paymentOption: PaymentMethodsRecord.paymentFieldsInfo,
~isActive: bool,
~checkoutEle: React.element,
~borderBottom: bool,
~borderRadiusStyle,
) => {
let {themeObj, localeString} = Recoil.useRecoilValueFromAtom(configAtom)
let {layout, customMethodNames} = Recoil.useRecoilValueFromAtom(optionAtom)
let layoutClass = CardUtils.getLayoutClass(layout)
let (selectedOption, setSelectedOption) = Recoil.useRecoilState(selectedOptionAtom)
let (
accordionClass,
accordionItemLabelClass,
accordionItemIconClass,
radioClass,
) = React.useMemo(
() =>
isActive
? (
"AccordionItem--selected",
"AccordionItemLabel--selected",
"AccordionItemIcon--selected",
true,
)
: ("", "", "", false),
[isActive],
)
let (displayName, icon) = PaymentUtils.getDisplayNameAndIcon(
customMethodNames,
paymentOption.paymentMethodName,
paymentOption.displayName,
paymentOption.icon,
)
<div
className={`AccordionItem flex flex-col`}
style={
minHeight: "60px",
width: "-webkit-fill-available",
cursor: "pointer",
marginBottom: layoutClass.spacedAccordionItems ? themeObj.spacingAccordionItem : "",
border: `1px solid ${themeObj.borderColor}`,
borderRadius: {borderRadiusStyle},
borderBottomStyle: borderBottom ? "solid" : "hidden",
}
onClick={_ => setSelectedOption(_ => paymentOption.paymentMethodName)}>
<div
className={`flex flex-row items-center ${accordionClass}`}
style={columnGap: themeObj.spacingUnit}>
<RenderIf condition=layoutClass.radios>
<Radio checked=radioClass />
</RenderIf>
<div className={`AccordionItemIcon ${accordionItemIconClass} flex items-center`}>
{switch icon {
| Some(ele) => ele
| None => React.string("<icon>")
}}
</div>
<div className={`AccordionItemLabel ${accordionItemLabelClass} flex items-center`}>
{React.string(paymentOption.paymentMethodName === "card" ? localeString.card : displayName)}
</div>
</div>
<RenderIf condition={selectedOption == paymentOption.paymentMethodName}>
<div className="mt-4 w-full"> {checkoutEle} </div>
</RenderIf>
</div>
}
| 539 | 10,424 |
hyperswitch-web
|
src/Components/SessionPaymentWrapper.res
|
.res
|
@react.component
let make = (~children, ~type_: SessionsType.paymentType) => {
let sessions = Recoil.useRecoilValueFromAtom(RecoilAtoms.sessions)
let loader = switch type_ {
| Others => <PaymentShimmer />
| Wallet => <WalletShimmer />
}
switch sessions {
| Loading => loader
| _ => children
}
}
| 85 | 10,425 |
hyperswitch-web
|
src/Components/FullNamePaymentInput.res
|
.res
|
open RecoilAtoms
open PaymentType
open Utils
@react.component
let make = (~paymentType, ~customFieldName=None, ~optionalRequiredFields=None) => {
let {localeString} = Recoil.useRecoilValueFromAtom(configAtom)
let {fields} = Recoil.useRecoilValueFromAtom(optionAtom)
let loggerState = Recoil.useRecoilValueFromAtom(loggerAtom)
let (fullName, setFullName) = Recoil.useLoggedRecoilState(userFullName, "fullName", loggerState)
let showDetails = getShowDetails(~billingDetails=fields.billingDetails, ~logger=loggerState)
let validateName = (
val: string,
prev: RecoilAtomTypes.field,
localeString: LocaleStringTypes.localeStrings,
) => {
let isValid = val !== "" && %re("/^\D*$/")->RegExp.test(val)
let errorString = if val === "" {
prev.errorString
} else if isValid {
""
} else {
localeString.invalidCardHolderNameError
}
{
...prev,
value: val,
isValid: Some(isValid),
errorString,
}
}
let changeName = ev => {
let val: string = ReactEvent.Form.target(ev)["value"]
setFullName(prev => validateName(val, prev, localeString))
}
let onBlur = ev => {
let val: string = ReactEvent.Focus.target(ev)["value"]
setFullName(prev => validateName(val, prev, localeString))
}
let (placeholder, fieldName) = switch customFieldName {
| Some(val) => (val, val)
| None => (localeString.fullNamePlaceholder, localeString.fullNameLabel)
}
let nameRef = React.useRef(Nullable.null)
let submitCallback = React.useCallback((ev: Window.event) => {
let json = ev.data->safeParse
let confirm = json->getDictFromJson->ConfirmType.itemToObjMapper
if confirm.doSubmit {
if fullName.value == "" {
setFullName(prev => {
...prev,
errorString: fieldName->localeString.nameEmptyText,
})
} else if !(fullName.isValid->Option.getOr(false)) {
setFullName(prev => {
...prev,
errorString: localeString.invalidCardHolderNameError,
})
} else {
switch optionalRequiredFields {
| Some(requiredFields) =>
if !DynamicFieldsUtils.checkIfNameIsValid(requiredFields, FullName, fullName) {
setFullName(prev => {
...prev,
errorString: fieldName->localeString.completeNameEmptyText,
})
}
| None => ()
}
}
}
}, [fullName])
useSubmitPaymentData(submitCallback)
<RenderIf condition={showDetails.name == Auto}>
<PaymentField
fieldName
setValue=setFullName
value=fullName
onChange=changeName
paymentType
onBlur
type_="text"
inputRef=nameRef
placeholder
name=TestUtils.fullNameInputTestId
/>
</RenderIf>
}
| 661 | 10,426 |
hyperswitch-web
|
src/hyper-loader/Types.res
|
.res
|
type eventData = {
iframeMounted: bool,
focus: bool,
blur: bool,
ready: bool,
clickTriggered: bool,
completeDoThis: bool,
elementType: string,
classChange: bool,
newClassType: string,
confirmTriggered: bool,
oneClickConfirmTriggered: bool,
}
type event = {key: string, data: eventData, source: Dom.element}
type eventParam = Event(event) | EventData(eventData) | Empty
type eventHandler = option<JSON.t> => unit
@send external onload: (Dom.element, unit => promise<'a>) => promise<'a> = "onload"
module This = {
type t
@get
external iframeElem: t => option<nullable<Dom.element>> = "iframeElem"
}
type paymentElement = {
on: (string, option<option<eventData> => unit>) => unit,
collapse: unit => unit,
blur: unit => unit,
update: JSON.t => unit,
destroy: unit => unit,
unmount: unit => unit,
mount: string => unit,
focus: unit => unit,
clear: unit => unit,
onSDKHandleClick: option<unit => Promise.t<unit>> => unit,
}
type element = {
getElement: string => option<paymentElement>,
update: JSON.t => unit,
fetchUpdates: unit => promise<JSON.t>,
create: (string, JSON.t) => paymentElement,
}
type getCustomerSavedPaymentMethods = {
getCustomerDefaultSavedPaymentMethodData: unit => JSON.t,
getCustomerLastUsedPaymentMethodData: unit => JSON.t,
confirmWithCustomerDefaultPaymentMethod: JSON.t => promise<JSON.t>,
confirmWithLastUsedPaymentMethod: JSON.t => promise<JSON.t>,
}
type getPaymentManagementMethods = {
getSavedPaymentManagementMethodsList: unit => promise<JSON.t>,
deleteSavedPaymentMethod: JSON.t => promise<JSON.t>,
}
type initPaymentSession = {
getCustomerSavedPaymentMethods: unit => promise<JSON.t>,
getPaymentManagementMethods: unit => promise<JSON.t>,
}
type confirmParams = {return_url: string}
type confirmPaymentParams = {
elements: JSON.t,
confirmParams: Nullable.t<confirmParams>,
}
type hyperInstance = {
confirmOneClickPayment: (JSON.t, bool) => promise<JSON.t>,
confirmPayment: JSON.t => promise<JSON.t>,
elements: JSON.t => element,
confirmCardPayment: (string, option<JSON.t>, option<JSON.t>) => promise<JSON.t>,
retrievePaymentIntent: string => promise<JSON.t>,
widgets: JSON.t => element,
paymentRequest: JSON.t => JSON.t,
initPaymentSession: JSON.t => initPaymentSession,
paymentMethodsManagementElements: JSON.t => element,
}
let oneClickConfirmPaymentFn = (_, _) => {
Promise.resolve(Dict.make()->JSON.Encode.object)
}
let confirmPaymentFn = (_elements: JSON.t) => {
Promise.resolve(Dict.make()->JSON.Encode.object)
}
let confirmCardPaymentFn = (
_clientSecretId: string,
_data: option<JSON.t>,
_options: option<JSON.t>,
) => {
Promise.resolve(Dict.make()->JSON.Encode.object)
}
let retrievePaymentIntentFn = _paymentIntentId => {
Promise.resolve(Dict.make()->JSON.Encode.object)
}
let update = _options => {
()
}
let getElement = _componentName => {
None
}
let fetchUpdates = () => {
Promise.make((resolve, _) => {
setTimeout(() => resolve(Dict.make()->JSON.Encode.object), 1000)->ignore
})
}
let fnArgument = Some(() => Promise.make((_, _) => {()}))
let defaultPaymentElement = {
on: (_str, _func) => (),
collapse: () => (),
blur: () => (),
update: _x => (),
destroy: () => (),
unmount: () => (),
mount: _string => (),
focus: () => (),
clear: () => (),
onSDKHandleClick: fnArgument => (),
}
let create = (_componentType, _options) => {
defaultPaymentElement
}
let defaultElement = {
getElement,
update,
fetchUpdates,
create,
}
let getCustomerDefaultSavedPaymentMethodData = () => {
JSON.Encode.null
}
let getSavedPaymentManagementMethodsList = () => {
JSON.Encode.null
}
let deleteSavedPaymentMethod = () => {
JSON.Encode.null
}
let getCustomerLastUsedPaymentMethodData = () => {
JSON.Encode.null
}
let confirmWithCustomerDefaultPaymentMethod = _confirmParams => {
Promise.resolve(Dict.make()->JSON.Encode.object)
}
let confirmWithLastUsedPaymentMethod = _confirmParams => {
Promise.resolve(Dict.make()->JSON.Encode.object)
}
let defaultGetCustomerSavedPaymentMethods = () => {
// TODO: After rescript migration to v11, add this without TAG using enums
// Promise.resolve({
// getCustomerDefaultSavedPaymentMethodData,
// confirmWithCustomerDefaultPaymentMethod,
// })
Promise.resolve(JSON.Encode.null)
}
let defaultGetPaymentManagementMethods = () => {
Promise.resolve(JSON.Encode.null)
}
let defaultInitPaymentSession: initPaymentSession = {
getCustomerSavedPaymentMethods: defaultGetCustomerSavedPaymentMethods,
getPaymentManagementMethods: defaultGetPaymentManagementMethods,
}
let defaultHyperInstance = {
confirmOneClickPayment: oneClickConfirmPaymentFn,
confirmPayment: confirmPaymentFn,
confirmCardPayment: confirmCardPaymentFn,
retrievePaymentIntent: retrievePaymentIntentFn,
elements: _ev => defaultElement,
widgets: _ev => defaultElement,
paymentRequest: _ev => JSON.Encode.null,
initPaymentSession: _ev => defaultInitPaymentSession,
paymentMethodsManagementElements: _ev => defaultElement,
}
type eventType =
| Escape
| Change
| Click
| Ready
| Focus
| Blur
| CompleteDoThis
| ConfirmPayment
| OneClickConfirmPayment
| None
let eventTypeMapper = event => {
switch event {
| "escape" => Escape
| "change" => Change
| "clickTriggered" => Click
| "ready" => Ready
| "completeDoThis" => CompleteDoThis
| "focus" => Focus
| "blur" => Blur
| "confirmTriggered" => ConfirmPayment
| "oneClickConfirmTriggered" => OneClickConfirmPayment
| _ => None
}
}
type rec ele = {
mutable id: string,
mutable src: string,
mutable name: string,
mutable style: string,
mutable onload: unit => unit,
mutable action: string,
mutable method: string,
mutable target: string,
mutable enctype: string,
mutable value: string,
submit: unit => unit,
appendChild: ele => unit,
}
@scope("document") @val external createElement: string => ele = "createElement"
@send external appendChild: (Dom.element, ele) => unit = "appendChild"
type hyperComponentName = Elements | PaymentMethodsManagementElements
let getStrFromHyperComponentName = hyperComponentName => {
switch hyperComponentName {
| Elements => "Elements"
| PaymentMethodsManagementElements => "PaymentMethodsManagementElements"
}
}
let getHyperComponentNameFromStr = hyperComponentName => {
switch hyperComponentName {
| "PaymentMethodsManagementElements" => PaymentMethodsManagementElements
| _ => Elements
}
}
| 1,645 | 10,427 |
hyperswitch-web
|
src/hyper-loader/PaymentSession.res
|
.res
|
open Types
let make = (
options,
~clientSecret,
~publishableKey,
~logger: option<HyperLogger.loggerMake>,
~ephemeralKey,
~redirectionFlags: RecoilAtomTypes.redirectionFlags,
) => {
let logger = logger->Option.getOr(HyperLogger.defaultLoggerConfig)
let customPodUri =
options
->JSON.Decode.object
->Option.flatMap(x => x->Dict.get("customPodUri"))
->Option.flatMap(JSON.Decode.string)
->Option.getOr("")
let endpoint = ApiEndpoint.getApiEndPoint(~publishableKey)
let defaultInitPaymentSession = {
getCustomerSavedPaymentMethods: _ =>
PaymentSessionMethods.getCustomerSavedPaymentMethods(
~clientSecret,
~publishableKey,
~endpoint,
~logger,
~customPodUri,
~redirectionFlags,
),
getPaymentManagementMethods: _ =>
PaymentSessionMethods.getPaymentManagementMethods(
~ephemeralKey,
~logger,
~customPodUri,
~endpoint,
),
}
defaultInitPaymentSession
}
| 239 | 10,428 |
hyperswitch-web
|
src/hyper-loader/LoaderPaymentElement.res
|
.res
|
open Types
open Utils
open EventListenerManager
open Identity
@val @scope(("navigator", "clipboard"))
external writeText: string => promise<'a> = "writeText"
let onCompleteDoThisUsed = ref(false)
let isPaymentButtonHandlerProvided = ref(false)
let make = (
componentType,
options,
setIframeRef,
iframeRef,
mountPostMessage,
~isPaymentManagementElement=false,
~redirectionFlags: RecoilAtomTypes.redirectionFlags,
) => {
try {
let mountId = ref("")
let setPaymentIframeRef = ref => {
setIframeRef(ref)
}
let (elementIframeWrapperDivId, elementIframeId) = if isPaymentManagementElement {
("management-element", "payment-methods-management-element")
} else {
("element", "payment-element")
}
let sdkHandleOneClickConfirmPayment =
options->getDecodedBoolFromJson(
callbackFuncForExtractingValFromDict("sdkHandleOneClickConfirmPayment"),
true,
)
let asyncWrapper = async fn => {
try {
await fn()
} catch {
| err => Console.error2("Async function call failure", err)
}
}
let currEventHandler = ref(Some(() => Promise.make((_, _) => {()})))
let walletOneClickEventHandler = (event: Types.event) => {
open Promise
let json = try {
event.data->anyTypeToJson
} catch {
| _ => JSON.Encode.null
}
let dict = json->getDictFromJson
if dict->Dict.get("oneClickConfirmTriggered")->Option.isSome {
switch currEventHandler.contents {
| Some(eH) =>
asyncWrapper(eH)
->then(() => {
let msg = [("walletClickEvent", true->JSON.Encode.bool)]->Dict.fromArray
event.source->Window.sendPostMessage(msg)
resolve()
})
->catch(_ => resolve())
->ignore
| None => ()
}
}
}
Window.addEventListener("message", walletOneClickEventHandler)
let onSDKHandleClick = (eventHandler: option<unit => Promise.t<'a>>) => {
currEventHandler := eventHandler
if eventHandler->Option.isSome {
isPaymentButtonHandlerProvided := true
}
}
let on = (eventType, eventHandler) => {
switch eventType->eventTypeMapper {
| Escape =>
addSmartEventListener(
"keypress",
(ev: Types.event) => {
if ev.key === "Escape" {
switch eventHandler {
| Some(eH) => eH(Some(ev.data))
| None => ()
}
}
},
"onEscape",
)
| CompleteDoThis =>
if eventHandler->Option.isSome {
eventHandlerFunc(
ev => ev.data.completeDoThis,
eventHandler,
CompleteDoThis,
"onCompleteDoThis",
)
}
| Change =>
eventHandlerFunc(
ev => ev.data.elementType === componentType,
eventHandler,
Change,
"onChange",
)
| Click => eventHandlerFunc(ev => ev.data.clickTriggered, eventHandler, Click, "onClick")
| Ready => eventHandlerFunc(ev => ev.data.ready, eventHandler, Ready, "onReady")
| Focus => eventHandlerFunc(ev => ev.data.focus, eventHandler, Focus, "onFocus")
| Blur => eventHandlerFunc(ev => ev.data.blur, eventHandler, Blur, "onBlur")
| ConfirmPayment =>
eventHandlerFunc(
ev => ev.data.confirmTriggered,
eventHandler,
ConfirmPayment,
"onHelpConfirmPayment",
)
| OneClickConfirmPayment =>
eventHandlerFunc(
ev => ev.data.oneClickConfirmTriggered,
eventHandler,
OneClickConfirmPayment,
"onHelpOneClickConfirmPayment",
)
| _ => ()
}
}
let collapse = () => ()
let blur = () => {
iframeRef->Array.forEach(iframe => {
let message = [("doBlur", true->JSON.Encode.bool)]->Dict.fromArray
iframe->Window.iframePostMessage(message)
})
}
let focus = () => {
iframeRef->Array.forEach(iframe => {
let message = [("doFocus", true->JSON.Encode.bool)]->Dict.fromArray
iframe->Window.iframePostMessage(message)
})
}
let clear = () => {
iframeRef->Array.forEach(iframe => {
let message = [("doClearValues", true->JSON.Encode.bool)]->Dict.fromArray
iframe->Window.iframePostMessage(message)
})
}
let unmount = () => {
let id = mountId.contents
let oElement = Window.querySelector(id)
switch oElement->Nullable.toOption {
| Some(elem) => elem->Window.innerHTML("")
| None =>
Console.warn(
"INTEGRATION ERROR: Div does not seem to exist on which payment element is to mount/unmount",
)
}
}
let destroy = () => {
unmount()
mountId := ""
}
let update = newOptions => {
let flatOption = options->flattenObject(true)
let newFlatOption = newOptions->flattenObject(true)
let keys = flatOption->Dict.keysToArray
keys->Array.forEach(key => {
switch newFlatOption->Dict.get(key) {
| Some(op) => flatOption->Dict.set(key, op)
| None => ()
}
})
let newEntries = newFlatOption->Dict.toArray
newEntries->Array.forEach(entries => {
let (key, value) = entries
if flatOption->Dict.get(key)->Option.isNone {
flatOption->Dict.set(key, value)
}
})
iframeRef->Array.forEach(iframe => {
let message =
[
("paymentElementsUpdate", true->JSON.Encode.bool),
("options", flatOption->JSON.Encode.object->unflattenObject->JSON.Encode.object),
]->Dict.fromArray
iframe->Window.iframePostMessage(message)
})
}
let mount = selector => {
mountId := selector
let localSelectorArr = selector->String.split("#")
let localSelectorString = localSelectorArr->Array.get(1)->Option.getOr("someString")
let iframeHeightRef = ref(25.0)
let currentClass = ref("base")
let fullscreen = ref(false)
let fullscreenParam = ref("")
let fullscreenMetadata = ref(Dict.make()->JSON.Encode.object)
let optionsDict = options->getDictFromJson
let handle = (ev: Types.event) => {
let eventDataObject = ev.data->anyTypeToJson
let iframeHeight = eventDataObject->getOptionalJsonFromJson("iframeHeight")
if iframeHeight->Option.isSome {
let iframeId =
eventDataObject
->getOptionalJsonFromJson("iframeId")
->getStringFromOptionalJson("no-element")
iframeHeightRef :=
iframeHeight->Option.getOr(JSON.Encode.null)->Utils.getFloatFromJson(200.0)
if iframeId === localSelectorString {
let elem = Window.querySelector(
`#orca-${elementIframeId}-iframeRef-${localSelectorString}`,
)
switch elem->Nullable.toOption {
| Some(ele) =>
switch iframeId {
| "payout-link" | "payment-method-collect" =>
ele
->Window.style
->Window.setHeight("100vh")
| _ =>
ele
->Window.style
->Window.setHeight(`${iframeHeightRef.contents->Float.toString}px`)
}
| None => ()
}
}
}
switch eventDataObject->getOptionalJsonFromJson("openurl") {
| Some(val) => {
let url = val->getStringFromJson("")
Utils.replaceRootHref(url, redirectionFlags)
}
| None => ()
}
let isCopy =
eventDataObject->getOptionalJsonFromJson("copy")->getBoolFromOptionalJson(false)
let text =
eventDataObject->getOptionalJsonFromJson("copyDetails")->getStringFromOptionalJson("")
if isCopy {
open Promise
writeText(text)->then(_ => resolve())->catch(_ => resolve())->ignore
}
let combinedHyperClasses = eventDataObject->getOptionalJsonFromJson("concatedString")
if combinedHyperClasses->Option.isSome {
let id = eventDataObject->getOptionalJsonFromJson("id")->getStringFromOptionalJson("")
let decodeStringTest = combinedHyperClasses->Option.flatMap(JSON.Decode.string)
switch decodeStringTest {
| Some(val) => currentClass := val
| None => ()
}
if id == localSelectorString {
let elem = Window.querySelector(
`#orca-${elementIframeWrapperDivId}-${localSelectorString}`,
)
switch elem->Nullable.toOption {
| Some(ele) => ele->Window.className(currentClass.contents)
| None => ()
}
}
}
let iframeMounted = eventDataObject->getOptionalJsonFromJson("iframeMounted")
let fullscreenIframe = eventDataObject->getOptionalJsonFromJson("fullscreen")
let param = eventDataObject->getOptionalJsonFromJson("param")
let metadata = eventDataObject->getOptionalJsonFromJson("metadata")
let iframeID =
eventDataObject->getOptionalJsonFromJson("iframeId")->getStringFromOptionalJson("")
if fullscreenIframe->Option.isSome {
fullscreen := fullscreenIframe->getBoolFromOptionalJson(false)
fullscreenParam := param->getStringFromOptionalJson("")
fullscreenMetadata :=
metadata
->Option.flatMap(JSON.Decode.object)
->Option.getOr(Dict.make())
->JSON.Encode.object
let fullscreenElem = Window.querySelector(
`#orca-fullscreen-iframeRef-${localSelectorString}`,
)
switch fullscreenElem->Nullable.toOption {
| Some(ele) =>
ele->Window.innerHTML("")
let mainElement = Window.querySelector(
`#orca-${elementIframeId}-iframeRef-${localSelectorString}`,
)
let iframeURL =
fullscreenParam.contents != ""
? `${ApiEndpoint.sdkDomainUrl}/fullscreenIndex.html?fullscreenType=${fullscreenParam.contents}`
: `${ApiEndpoint.sdkDomainUrl}/fullscreenIndex.html?fullscreenType=fullscreen`
fullscreen.contents
? {
if iframeID == localSelectorString {
let handleFullScreenCallback = (ev: Types.event) => {
let json = ev.data->anyTypeToJson
let dict = json->Utils.getDictFromJson
if dict->Dict.get("iframeMountedCallback")->Option.isSome {
let fullScreenEle = Window.querySelector(`#orca-fullscreen`)
fullScreenEle->Window.iframePostMessage(
[
("fullScreenIframeMounted", true->JSON.Encode.bool),
("metadata", fullscreenMetadata.contents),
("options", options),
]->Dict.fromArray,
)
}
if dict->Dict.get("driverMounted")->Option.isSome {
mainElement->Window.iframePostMessage(
[
("fullScreenIframeMounted", true->JSON.Encode.bool),
("metadata", fullscreenMetadata.contents),
("options", options),
]->Dict.fromArray,
)
let fullScreenEle = Window.querySelector(`#orca-fullscreen`)
fullScreenEle->Window.iframePostMessage(
[("metadata", fullscreenMetadata.contents)]->Dict.fromArray,
)
}
}
addSmartEventListener(
"message",
handleFullScreenCallback,
"onFullScreenCallback",
)
ele->makeIframe(iframeURL)->ignore
}
}
: {
ele->Window.innerHTML("")
mainElement->Window.iframePostMessage(
[
("fullScreenIframeMounted", false->JSON.Encode.bool),
("options", options),
]->Dict.fromArray,
)
}
| None => ()
}
}
if iframeMounted->Option.isSome {
mountPostMessage(
Window.querySelector(`#orca-${elementIframeId}-iframeRef-${localSelectorString}`),
localSelectorString,
sdkHandleOneClickConfirmPayment,
)
}
}
addSmartEventListener("message", handle, `onMount-${componentType}`)
let oElement = Window.querySelector(selector)
let classesBase = optionsDict->getClasses("base")
let additionalIframeStyle =
componentType->Utils.isOtherElements ? "height: 2rem;" : "height: 0;"
switch oElement->Nullable.toOption {
| Some(elem) => {
let iframeDiv = `<div id="orca-${elementIframeWrapperDivId}-${localSelectorString}" style="height: auto; font-size: 0;" class="${componentType} ${currentClass.contents} ${classesBase}">
<div id="orca-fullscreen-iframeRef-${localSelectorString}"></div>
<iframe
id ="orca-${elementIframeId}-iframeRef-${localSelectorString}"
name="orca-${elementIframeId}-iframeRef-${localSelectorString}"
src="${ApiEndpoint.sdkDomainUrl}/index.html?componentName=${componentType}"
allow="payment *"
title="Orca Payment Element Frame"
sandbox="allow-scripts allow-popups allow-same-origin allow-forms"
name="orca-payment"
style="border: 0px; ${additionalIframeStyle} outline: none;"
width="100%"
></iframe>
</div>`
elem->Window.innerHTML(iframeDiv)
setPaymentIframeRef(
Window.querySelector(`#orca-${elementIframeId}-iframeRef-${localSelectorString}`),
)
let elem = Window.querySelector(
`#orca-${elementIframeId}-iframeRef-${localSelectorString}`,
)
switch elem->Nullable.toOption {
| Some(ele) =>
ele->Window.style->Window.setTransition("height 0.35s ease 0s, opacity 0.4s ease 0.1s")
| None => ()
}
}
| None => ()
}
}
{
on,
collapse,
blur,
focus,
clear,
unmount,
destroy,
update,
mount,
onSDKHandleClick,
}
} catch {
| e => {
Sentry.captureException(e)
defaultPaymentElement
}
}
}
| 3,085 | 10,429 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.