@easyflow/javascript-sdk 2.1.8 → 2.1.9

package/libs/utils.mjs

@@ -1,368 +0,0 @@
-/**
- * Utility functions for Easyflow SDK
- */
-
-import { PAYMENT_METHODS } from '../sdk.mjs'
-
-/**
- * Deep clone an object using JSON serialization
- * @param {*} data - Data to clone
- * @returns {*} Cloned data
- */
-export function deepClone(data) {
-    return JSON.parse(JSON.stringify(data))
-}
-
-/**
- * Prepare order data by mapping payments
- * @param {Object} data - Order data
- * @returns {Object} Prepared order data
- */
-export function mapCreditCardIfNeeded(data) {
-    const clonedData = deepClone(data)
-    clonedData.payments = clonedData.payments.map((payment) => {
-        if (payment.method === PAYMENT_METHODS.CREDIT_CARD) {
-            return {
-                ...payment,
-                rawCreditCard: payment.creditCard,
-            }
-        }
-        return payment
-    })
-    return clonedData
-}
-
-/**
- * Find payment by method in order data
- * @param {Object} order - Order data
- * @param {string} method - Payment method to find
- * @param {Function} validator - Validation function for the payment data
- * @returns {Object|null} Payment data or null if not found
- */
-export function findPaymentByMethod(order, method, validator) {
-    if (!order?.payments?.length) {
-        return null
-    }
-
-    const payment = order.payments.find(
-        (payment) => payment.method === method && validator(payment)
-    )
-
-    return payment || null
-}
-
-/**
- * Validate PIX payment data
- * @param {Object} payment - Payment object
- * @returns {boolean} True if valid PIX payment
- */
-export function isValidPixPayment(payment) {
-    return payment.pix && (payment.pix.qrCode || payment.pix.copyAndPasteCode)
-}
-
-/**
- * Validate bank billet payment data
- * @param {Object} payment - Payment object
- * @returns {boolean} True if valid bank billet payment
- */
-export function isValidBankBilletPayment(payment) {
-    return (
-        payment.bankBillet &&
-        (payment.bankBillet.link ||
-            payment.bankBillet.line ||
-            payment.bankBillet.barCode)
-    )
-}
-
-/**
- * Merge headers with default headers
- * @param {Object} defaultHeaders - Default headers
- * @param {Object} additionalHeaders - Additional headers
- * @returns {Object} Merged headers
- */
-export function mergeHeaders(defaultHeaders = {}, additionalHeaders = {}) {
-    return { ...defaultHeaders, ...additionalHeaders }
-}
-
-/**
- * Build API URL with target and parameters
- * @param {string} baseUrl - Base URL
- * @param {string} target - API target
- * @param {Object} params - URL parameters
- * @returns {string} Complete API URL
- */
-export function buildApiUrl(baseUrl, target, params = {}) {
-    const url = new URL(`/api/proxy?target=${target}`, baseUrl).toString()
-    const queryParams = new URLSearchParams(params).toString()
-    return queryParams ? `${url}&${queryParams}` : url
-}
-
-/**
- * Generate browser fingerprint for security and tracking
- * @param {Object} options - Fingerprint options
- * @param {boolean} options.hardwareOnly - Only use hardware-based data
- * @param {boolean} options.enableWebgl - Enable WebGL fingerprinting
- * @param {boolean} options.debug - Enable debug logging
- * @returns {string} Fingerprint hash
- */
-export function getBrowserFingerprint({ hardwareOnly = false, enableWebgl = false, debug = false } = {}) {
-    const {
-        cookieEnabled,
-        deviceMemory,
-        doNotTrack,
-        hardwareConcurrency,
-        language,
-        languages,
-        maxTouchPoints,
-        platform,
-        userAgent,
-        vendor
-    } = window.navigator
-
-    let { width, height, colorDepth, pixelDepth } = window.screen
-    width = 1000
-    height = 1000
-
-    const timezoneOffset = (new Date()).getTimezoneOffset()
-    const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone
-    const touchSupport = 'ontouchstart' in window
-    const devicePixelRatio = window.devicePixelRatio
-    const canvas = getCanvasID(debug)
-    const webgl = enableWebgl ? getWebglID(debug) : undefined
-    const webglInfo = enableWebgl ? getWebglInfo(debug) : undefined
-
-    const fingerprintData = hardwareOnly
-        ? JSON.stringify({
-            canvas,
-            colorDepth,
-            deviceMemory,
-            devicePixelRatio,
-            hardwareConcurrency,
-            height,
-            maxTouchPoints,
-            pixelDepth,
-            platform,
-            touchSupport,
-            webgl,
-            webglInfo,
-            width
-        })
-        : JSON.stringify({
-            canvas,
-            colorDepth,
-            cookieEnabled,
-            deviceMemory,
-            devicePixelRatio,
-            doNotTrack,
-            hardwareConcurrency,
-            height,
-            language,
-            languages,
-            maxTouchPoints,
-            pixelDepth,
-            platform,
-            timezone,
-            timezoneOffset,
-            touchSupport,
-            userAgent,
-            vendor,
-            webgl,
-            webglInfo,
-            width
-        })
-
-    const fingerprintJson = JSON.stringify(fingerprintData, null, 4)
-
-    if (debug) {
-        console.log('fingerprint data', fingerprintJson)
-    }
-
-    return murmurhash3_32_gc(fingerprintJson)
-}
-
-/**
- * Generate canvas fingerprint ID
- * @param {boolean} debug - Enable debug mode
- * @returns {string|null} Canvas fingerprint hash
- */
-function getCanvasID(debug = false) {
-    try {
-        const canvas = document.createElement('canvas')
-        const ctx = canvas.getContext('2d')
-        const text = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ`~1!2@3#4$5%6^7&8*9(0)-_=+[{]}|;:\',<.>/?'
-
-        ctx.textBaseline = 'top'
-        ctx.font = '14px \'Arial\''
-        ctx.textBaseline = 'alphabetic'
-        ctx.fillStyle = '#f60'
-        ctx.fillRect(125, 1, 62, 20)
-        ctx.fillStyle = '#069'
-        ctx.fillText(text, 2, 15)
-        ctx.fillStyle = 'rgba(102, 204, 0, 0.7)'
-        ctx.fillText(text, 4, 17)
-
-        const dataURL = canvas.toDataURL()
-
-        if (debug) {
-            document.body.appendChild(canvas)
-        } else {
-            ctx.clearRect(0, 0, canvas.width, canvas.height)
-        }
-
-        return murmurhash3_32_gc(dataURL)
-    } catch {
-        return null
-    }
-}
-
-/**
- * Generate WebGL fingerprint ID
- * @param {boolean} debug - Enable debug mode
- * @returns {string|null} WebGL fingerprint hash
- */
-function getWebglID(debug = false) {
-    try {
-        const canvas = document.createElement('canvas')
-        const gl = canvas.getContext('webgl')
-
-        canvas.width = 256
-        canvas.height = 128
-
-        const vertexShaderSource = `
-            attribute vec2 attrVertex;
-            varying vec2 varyinTexCoordinate;
-            uniform vec2 uniformOffset;
-            void main() {
-                varyinTexCoordinate = attrVertex + uniformOffset;
-                gl_Position = vec4(attrVertex, 0, 1);
-            }
-        `
-
-        const fragmentShaderSource = `
-            precision mediump float;
-            varying vec2 varyinTexCoordinate;
-            void main() {
-                gl_FragColor = vec4(varyinTexCoordinate, 0, 1);
-            }
-        `
-
-        const buffer = gl.createBuffer()
-        gl.bindBuffer(gl.ARRAY_BUFFER, buffer)
-
-        const vertices = new Float32Array([-0.2, -0.9, 0, 0.4, -0.26, 0, 0, 0.7321, 0])
-        gl.bufferData(gl.ARRAY_BUFFER, vertices, gl.STATIC_DRAW)
-        buffer.itemSize = 3
-        buffer.numItems = 3
-
-        const program = gl.createProgram()
-        const vertexShader = gl.createShader(gl.VERTEX_SHADER)
-        gl.shaderSource(vertexShader, vertexShaderSource)
-        gl.compileShader(vertexShader)
-
-        const fragmentShader = gl.createShader(gl.FRAGMENT_SHADER)
-        gl.shaderSource(fragmentShader, fragmentShaderSource)
-        gl.compileShader(fragmentShader)
-
-        gl.attachShader(program, vertexShader)
-        gl.attachShader(program, fragmentShader)
-        gl.linkProgram(program)
-        gl.useProgram(program)
-
-        program.vertexPosAttrib = gl.getAttribLocation(program, 'attrVertex')
-        program.offsetUniform = gl.getUniformLocation(program, 'uniformOffset')
-
-        gl.enableVertexAttribArray(program.vertexPosAttrib)
-        gl.vertexAttribPointer(program.vertexPosAttrib, buffer.itemSize, gl.FLOAT, false, 0, 0)
-        gl.uniform2f(program.offsetUniform, 1, 1)
-        gl.drawArrays(gl.TRIANGLE_STRIP, 0, buffer.numItems)
-
-        const pixels = new Uint8Array(canvas.width * canvas.height * 4)
-        gl.readPixels(0, 0, canvas.width, canvas.height, gl.RGBA, gl.UNSIGNED_BYTE, pixels)
-
-        const pixelsString = JSON.stringify(pixels).replace(/,?"[0-9]+":/g, '')
-
-        if (debug) {
-            document.body.appendChild(canvas)
-        } else {
-            gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT | gl.STENCIL_BUFFER_BIT)
-        }
-
-        return murmurhash3_32_gc(pixelsString)
-    } catch {
-        return null
-    }
-}
-
-/**
- * Get WebGL information
- * @param {boolean} debug - Enable debug mode
- * @returns {Object|null} WebGL information
- */
-function getWebglInfo(debug = false) {
-    try {
-        const canvas = document.createElement('canvas')
-        const gl = canvas.getContext('webgl')
-
-        return {
-            VERSION: gl.getParameter(gl.VERSION),
-            SHADING_LANGUAGE_VERSION: gl.getParameter(gl.SHADING_LANGUAGE_VERSION),
-            VENDOR: gl.getParameter(gl.VENDOR),
-            SUPORTED_EXTENSIONS: gl.getSupportedExtensions()
-        }
-    } catch {
-        return null
-    }
-}
-
-/**
- * MurmurHash3 implementation for fingerprint generation
- * @param {string} str - String to hash
- * @returns {string} Hash result
- */
-function murmurhash3_32_gc(str) {
-    const c1 = 0xcc9e2d51
-    const c2 = 0x1b873593
-    const r1 = 15
-    const r2 = 13
-    const m = 5
-    const n = 0xe6546b64
-
-    let h = 0xdeadbeef
-    let k
-
-    for (let i = 0; i < str.length; i += 4) {
-        k = str.charCodeAt(i) |
-            (str.charCodeAt(i + 1) << 8) |
-            (str.charCodeAt(i + 2) << 16) |
-            (str.charCodeAt(i + 3) << 24)
-
-        k = Math.imul(k, c1)
-        k = (k << r1) | (k >>> (32 - r1))
-        k = Math.imul(k, c2)
-
-        h ^= k
-        h = (h << r2) | (h >>> (32 - r2))
-        h = Math.imul(h, m) + n
-    }
-
-    const remaining = str.length % 4
-    if (remaining > 0) {
-        let k = 0
-        for (let i = str.length - remaining; i < str.length; i++) {
-            k |= str.charCodeAt(i) << ((i - (str.length - remaining)) * 8)
-        }
-        k = Math.imul(k, c1)
-        k = (k << r1) | (k >>> (32 - r1))
-        k = Math.imul(k, c2)
-        h ^= k
-    }
-
-    h ^= str.length
-    h ^= h >>> 16
-    h = Math.imul(h, 0x85ebca6b)
-    h ^= h >>> 13
-    h = Math.imul(h, 0xc2b2ae35)
-    h ^= h >>> 16
-
-    return (h >>> 0).toString(16)
-}

package/libs/utils.spec.js

@@ -1,231 +0,0 @@
-import { jest, describe, it, expect, beforeEach } from '@jest/globals'
-
-// Mock PAYMENT_METHODS para evitar import do SDK completo
-await jest.unstable_mockModule('../sdk.mjs', () => ({
-    PAYMENT_METHODS: {
-        CREDIT_CARD: 'credit-card',
-        PIX: 'pix',
-        BANK_BILLET: 'bank-billet',
-    },
-}))
-
-const {
-    deepClone,
-    mapCreditCardIfNeeded,
-    findPaymentByMethod,
-    isValidPixPayment,
-    isValidBankBilletPayment,
-    mergeHeaders,
-    buildApiUrl,
-} = await import('./utils.mjs')
-
-describe('Utils', () => {
-    describe('deepClone', () => {
-        it('should clone simple object', () => {
-            const obj = { a: 1, b: 'x' }
-            const cloned = deepClone(obj)
-            expect(cloned).toEqual(obj)
-            expect(cloned).not.toBe(obj)
-        })
-
-        it('should clone nested object', () => {
-            const obj = { a: { b: { c: 1 } } }
-            const cloned = deepClone(obj)
-            expect(cloned).toEqual(obj)
-            expect(cloned.a).not.toBe(obj.a)
-        })
-
-        it('should clone array', () => {
-            const arr = [1, { a: 2 }, [3]]
-            const cloned = deepClone(arr)
-            expect(cloned).toEqual(arr)
-            expect(cloned).not.toBe(arr)
-        })
-
-        it('should handle primitive values', () => {
-            expect(deepClone(1)).toBe(1)
-            expect(deepClone('x')).toBe('x')
-            expect(deepClone(true)).toBe(true)
-        })
-
-        it('should handle empty objects and arrays', () => {
-            expect(deepClone({})).toEqual({})
-            expect(deepClone([])).toEqual([])
-        })
-    })
-
-    describe('mapCreditCardIfNeeded', () => {
-        it('should map credit card payment correctly', () => {
-            const data = {
-                payments: [
-                    { method: 'credit-card', creditCard: { token: 't', n: 1 } },
-                ],
-            }
-            const result = mapCreditCardIfNeeded(data)
-            expect(result).not.toBe(data)
-            expect(result.payments[0].rawCreditCard).toEqual({
-                token: 't',
-                n: 1,
-            })
-            // não deve remover creditCard original
-            expect(result.payments[0].creditCard).toEqual({ token: 't', n: 1 })
-        })
-
-        it('should not modify non-credit-card payments', () => {
-            const data = {
-                payments: [{ method: 'pix' }, { method: 'bank-billet' }],
-            }
-            const result = mapCreditCardIfNeeded(data)
-            expect(result.payments).toEqual(data.payments)
-        })
-
-        it('should handle mixed payment methods', () => {
-            const data = {
-                payments: [
-                    { method: 'pix' },
-                    { method: 'credit-card', creditCard: { token: 'abc' } },
-                ],
-            }
-            const result = mapCreditCardIfNeeded(data)
-            expect(result.payments[1].rawCreditCard).toEqual({ token: 'abc' })
-        })
-
-        it('should return deep clone of original data', () => {
-            const data = {
-                payments: [{ method: 'credit-card', creditCard: { t: 'x' } }],
-            }
-            const result = mapCreditCardIfNeeded(data)
-            expect(result).toEqual({
-                payments: [
-                    {
-                        method: 'credit-card',
-                        creditCard: { t: 'x' },
-                        rawCreditCard: { t: 'x' },
-                    },
-                ],
-            })
-            expect(result).not.toBe(data)
-        })
-    })
-
-    describe('findPaymentByMethod', () => {
-        it('should find payment by method when validator returns true', () => {
-            const order = {
-                payments: [{ method: 'pix', pix: { qrCode: 'q' } }],
-            }
-            const validator = (p) => !!p.pix?.qrCode
-            const found = findPaymentByMethod(order, 'pix', validator)
-            expect(found).toEqual(order.payments[0])
-        })
-
-        it('should return null when validator returns false', () => {
-            const order = { payments: [{ method: 'pix', pix: {} }] }
-            const validator = (p) => !!p.pix?.qrCode
-            expect(findPaymentByMethod(order, 'pix', validator)).toBeNull()
-        })
-
-        it('should return null when payment method not found', () => {
-            expect(
-                findPaymentByMethod({ payments: [] }, 'pix', () => true)
-            ).toBeNull()
-        })
-
-        it('should return null when order has no payments', () => {
-            expect(findPaymentByMethod({}, 'pix', () => true)).toBeNull()
-            expect(findPaymentByMethod(null, 'pix', () => true)).toBeNull()
-        })
-    })
-
-    describe('isValidPixPayment', () => {
-        it('should return true for valid PIX payment with qrCode', () => {
-            expect(!!isValidPixPayment({ pix: { qrCode: 'x' } })).toBe(true)
-        })
-        it('should return true for valid PIX payment with copyAndPasteCode', () => {
-            expect(
-                !!isValidPixPayment({ pix: { copyAndPasteCode: 'y' } })
-            ).toBe(true)
-        })
-        it('should return false for invalid pix object', () => {
-            expect(!!isValidPixPayment({})).toBe(false)
-            expect(!!isValidPixPayment({ pix: {} })).toBe(false)
-            expect(!!isValidPixPayment({ pix: null })).toBe(false)
-        })
-    })
-
-    describe('isValidBankBilletPayment', () => {
-        it('should return true for valid bank billet with link', () => {
-            expect(
-                !!isValidBankBilletPayment({ bankBillet: { link: 'l' } })
-            ).toBe(true)
-        })
-        it('should return true for valid bank billet with line', () => {
-            expect(
-                !!isValidBankBilletPayment({ bankBillet: { line: 'ln' } })
-            ).toBe(true)
-        })
-        it('should return true for valid bank billet with barCode', () => {
-            expect(
-                !!isValidBankBilletPayment({ bankBillet: { barCode: 'bc' } })
-            ).toBe(true)
-        })
-        it('should return false for invalid bank billet object', () => {
-            expect(!!isValidBankBilletPayment({})).toBe(false)
-            expect(!!isValidBankBilletPayment({ bankBillet: {} })).toBe(false)
-            expect(!!isValidBankBilletPayment({ bankBillet: null })).toBe(false)
-        })
-    })
-
-    describe('mergeHeaders', () => {
-        it('should merge headers correctly and override defaults', () => {
-            const defaults = { A: '1', B: '2' }
-            const add = { B: '3', C: '4' }
-            expect(mergeHeaders(defaults, add)).toEqual({
-                A: '1',
-                B: '3',
-                C: '4',
-            })
-        })
-
-        it('should handle empty and undefined headers', () => {
-            expect(mergeHeaders({}, {})).toEqual({})
-            expect(mergeHeaders(undefined, { A: '1' })).toEqual({ A: '1' })
-            expect(mergeHeaders({ A: '1' }, undefined)).toEqual({ A: '1' })
-        })
-    })
-
-    describe('buildApiUrl', () => {
-        const baseUrl = 'https://api.example.com'
-
-        it('should build URL with target only', () => {
-            const url = buildApiUrl(baseUrl, 'get-offer')
-            // accept with or without origin
-            expect(url).toMatch(
-                /(https:\/\/api\.example\.com)?\/api\/proxy\?target=get-offer/
-            )
-        })
-
-        it('should build URL with target and parameters', () => {
-            const url = buildApiUrl(baseUrl, 'get-order', { orderId: '123' })
-            expect(url).toMatch(
-                /(https:\/\/api\.example\.com)?\/api\/proxy\?target=get-order&orderId=123/
-            )
-        })
-
-        it('should handle empty and undefined params', () => {
-            expect(buildApiUrl(baseUrl, 'x', {})).toMatch(
-                /(https:\/\/api\.example\.com)?\/api\/proxy\?target=x/
-            )
-            expect(buildApiUrl(baseUrl, 'y')).toMatch(
-                /(https:\/\/api\.example\.com)?\/api\/proxy\?target=y/
-            )
-        })
-
-        it('should encode URL parameters correctly', () => {
-            const url = buildApiUrl(baseUrl, 'search', { q: 'a b+c' })
-            // allow + or %20 for space encoding
-            expect(url).toMatch(
-                /(https:\/\/api\.example\.com)?\/api\/proxy\?target=search&q=a(\+|%20)b%2Bc/
-            )
-        })
-    })
-})