emblem-vault-sdk 1.10.0 → 1.10.2

package/dist/bundle.js

@@ -711421,7 +711421,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const bignumber_1 = require("@ethersproject/bignumber");
 const utils_1 = require("./utils");
 const derive_1 = require("./derive");
-const SDK_VERSION = '1.10.0';
+const SDK_VERSION = '1.10.2';
 class EmblemVaultSDK {
     constructor(apiKey, baseUrl) {
         this.apiKey = apiKey;
@@ -712628,33 +712628,91 @@ exports.getLegacyContract = getLegacyContract;
 function checkContentType(url) {
     return new Promise((resolve, reject) => {
         let returnVal = { valid: false };
-        try {
-            fetch(url, { method: 'HEAD' })
+        // Function to make fetch requests
+        function fetchUrl(method) {
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), 3000); // 10 seconds timeout
+            return fetch(url, { method: method, signal: controller.signal })
                 .then(response => {
+                clearTimeout(timeoutId);
                 if (!response.ok) {
                     returnVal.valid = false;
+                    return resolve(returnVal);
                 }
                 else if (response.status === 200) {
                     const contentType = response.headers.get('content-type');
-                    let extension = getFileExtensionFromMimeType(contentType);
-                    returnVal.valid = true;
-                    returnVal.contentType = contentType;
-                    returnVal.extension = extension;
-                    returnVal.embed = !isValidDirect(extension);
-                    console.log('Content-Type:', contentType);
+                    if (!contentType && method === 'HEAD') {
+                        // If content-type is not found in HEAD, make a GET request
+                        return fetchUrl('GET');
+                    }
+                    else {
+                        // Process the content type and resolve the promise
+                        let extension = getFileExtensionFromMimeType(contentType);
+                        returnVal.valid = true;
+                        returnVal.contentType = contentType;
+                        returnVal.extension = extension;
+                        returnVal.method = method;
+                        returnVal.embed = !isValidDirect(extension);
+                        console.log('Content-Type:', contentType);
+                        return resolve(returnVal);
+                    }
+                }
+                else {
+                    return resolve(returnVal);
                 }
-                resolve(returnVal);
             })
                 .catch(error => {
+                clearTimeout(timeoutId);
                 console.error('Error while fetching URL:', error);
-                resolve(returnVal);
+                return resolve(returnVal);
             });
         }
-        catch (error) {
-        }
+        // Start with a HEAD request
+        fetchUrl('HEAD').catch((error) => {
+            console.error('Initial fetch error:', error);
+            resolve(returnVal);
+        });
     });
 }
 exports.checkContentType = checkContentType;
+// export function checkContentType(url: string) {
+//     return new Promise((resolve, reject) => {
+//         // Making a HTTP HEAD request to get only the headers
+//         type ReturnVal = { valid?: boolean, contentType?: string | null, extension?: string, embed?: boolean, method?: string};
+//         let returnVal: ReturnVal = {valid: false};
+//         function fetchUrl(method: string) {
+//             fetch(url, { method: method })
+//                 .then(response => {
+//                     if (!response.ok) {
+//                         returnVal.valid = false                    
+//                     } 
+//                     else if (response.status === 200) {
+//                         const contentType = response.headers.get('content-type');
+//                         if (!contentType) {
+//                             return fetchUrl('GET')
+//                         } else {
+//                             let extension = getFileExtensionFromMimeType(contentType)
+//                             returnVal.valid = true
+//                             returnVal.contentType = contentType
+//                             returnVal.extension = extension 
+//                             returnVal.method = method
+//                             returnVal.embed = !isValidDirect(extension)
+//                             console.log('Content-Type:', contentType);
+//                         }
+//                     } 
+//                     return resolve(returnVal);
+//                 })
+//                 .catch(error => {
+//                     console.error('Error while fetching URL:', error);
+//                     resolve(returnVal);
+//                 });                
+//         }
+//         try {
+//             fetchUrl('HEAD');
+//         } catch (error) {
+//         }
+//     });
+// }
 function isValidDirect(extension) {
     switch (extension) {
         case '.png':

package/dist/index.js

@@ -35,7 +35,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const bignumber_1 = require("@ethersproject/bignumber");
 const utils_1 = require("./utils");
 const derive_1 = require("./derive");
-const SDK_VERSION = '1.10.0';
+const SDK_VERSION = '1.10.2';
 class EmblemVaultSDK {
     constructor(apiKey, baseUrl) {
         this.apiKey = apiKey;

package/dist/utils.js

@@ -599,33 +599,91 @@ exports.getLegacyContract = getLegacyContract;
 function checkContentType(url) {
     return new Promise((resolve, reject) => {
         let returnVal = { valid: false };
-        try {
-            fetch(url, { method: 'HEAD' })
+        // Function to make fetch requests
+        function fetchUrl(method) {
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), 3000); // 10 seconds timeout
+            return fetch(url, { method: method, signal: controller.signal })
                 .then(response => {
+                clearTimeout(timeoutId);
                 if (!response.ok) {
                     returnVal.valid = false;
+                    return resolve(returnVal);
                 }
                 else if (response.status === 200) {
                     const contentType = response.headers.get('content-type');
-                    let extension = getFileExtensionFromMimeType(contentType);
-                    returnVal.valid = true;
-                    returnVal.contentType = contentType;
-                    returnVal.extension = extension;
-                    returnVal.embed = !isValidDirect(extension);
-                    console.log('Content-Type:', contentType);
-                }
-                resolve(returnVal);
+                    if (!contentType && method === 'HEAD') {
+                        // If content-type is not found in HEAD, make a GET request
+                        return fetchUrl('GET');
+                    }
+                    else {
+                        // Process the content type and resolve the promise
+                        let extension = getFileExtensionFromMimeType(contentType);
+                        returnVal.valid = true;
+                        returnVal.contentType = contentType;
+                        returnVal.extension = extension;
+                        returnVal.method = method;
+                        returnVal.embed = !isValidDirect(extension);
+                        console.log('Content-Type:', contentType);
+                        return resolve(returnVal);
+                    }
+                }
+                else {
+                    return resolve(returnVal);
+                }
             })
                 .catch(error => {
+                clearTimeout(timeoutId);
                 console.error('Error while fetching URL:', error);
-                resolve(returnVal);
+                return resolve(returnVal);
             });
         }
-        catch (error) {
-        }
+        // Start with a HEAD request
+        fetchUrl('HEAD').catch((error) => {
+            console.error('Initial fetch error:', error);
+            resolve(returnVal);
+        });
     });
 }
 exports.checkContentType = checkContentType;
+// export function checkContentType(url: string) {
+//     return new Promise((resolve, reject) => {
+//         // Making a HTTP HEAD request to get only the headers
+//         type ReturnVal = { valid?: boolean, contentType?: string | null, extension?: string, embed?: boolean, method?: string};
+//         let returnVal: ReturnVal = {valid: false};
+//         function fetchUrl(method: string) {
+//             fetch(url, { method: method })
+//                 .then(response => {
+//                     if (!response.ok) {
+//                         returnVal.valid = false                    
+//                     } 
+//                     else if (response.status === 200) {
+//                         const contentType = response.headers.get('content-type');
+//                         if (!contentType) {
+//                             return fetchUrl('GET')
+//                         } else {
+//                             let extension = getFileExtensionFromMimeType(contentType)
+//                             returnVal.valid = true
+//                             returnVal.contentType = contentType
+//                             returnVal.extension = extension 
+//                             returnVal.method = method
+//                             returnVal.embed = !isValidDirect(extension)
+//                             console.log('Content-Type:', contentType);
+//                         }
+//                     } 
+//                     return resolve(returnVal);
+//                 })
+//                 .catch(error => {
+//                     console.error('Error while fetching URL:', error);
+//                     resolve(returnVal);
+//                 });                
+//         }
+//         try {
+//             fetchUrl('HEAD');
+//         } catch (error) {
+//         }
+//     });
+// }
 function isValidDirect(extension) {
     switch (extension) {
         case '.png':

package/docs/bundle.js

@@ -711421,7 +711421,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const bignumber_1 = require("@ethersproject/bignumber");
 const utils_1 = require("./utils");
 const derive_1 = require("./derive");
-const SDK_VERSION = '1.10.0';
+const SDK_VERSION = '1.10.2';
 class EmblemVaultSDK {
     constructor(apiKey, baseUrl) {
         this.apiKey = apiKey;
@@ -712628,33 +712628,91 @@ exports.getLegacyContract = getLegacyContract;
 function checkContentType(url) {
     return new Promise((resolve, reject) => {
         let returnVal = { valid: false };
-        try {
-            fetch(url, { method: 'HEAD' })
+        // Function to make fetch requests
+        function fetchUrl(method) {
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), 3000); // 10 seconds timeout
+            return fetch(url, { method: method, signal: controller.signal })
                 .then(response => {
+                clearTimeout(timeoutId);
                 if (!response.ok) {
                     returnVal.valid = false;
+                    return resolve(returnVal);
                 }
                 else if (response.status === 200) {
                     const contentType = response.headers.get('content-type');
-                    let extension = getFileExtensionFromMimeType(contentType);
-                    returnVal.valid = true;
-                    returnVal.contentType = contentType;
-                    returnVal.extension = extension;
-                    returnVal.embed = !isValidDirect(extension);
-                    console.log('Content-Type:', contentType);
+                    if (!contentType && method === 'HEAD') {
+                        // If content-type is not found in HEAD, make a GET request
+                        return fetchUrl('GET');
+                    }
+                    else {
+                        // Process the content type and resolve the promise
+                        let extension = getFileExtensionFromMimeType(contentType);
+                        returnVal.valid = true;
+                        returnVal.contentType = contentType;
+                        returnVal.extension = extension;
+                        returnVal.method = method;
+                        returnVal.embed = !isValidDirect(extension);
+                        console.log('Content-Type:', contentType);
+                        return resolve(returnVal);
+                    }
+                }
+                else {
+                    return resolve(returnVal);
                 }
-                resolve(returnVal);
             })
                 .catch(error => {
+                clearTimeout(timeoutId);
                 console.error('Error while fetching URL:', error);
-                resolve(returnVal);
+                return resolve(returnVal);
             });
         }
-        catch (error) {
-        }
+        // Start with a HEAD request
+        fetchUrl('HEAD').catch((error) => {
+            console.error('Initial fetch error:', error);
+            resolve(returnVal);
+        });
     });
 }
 exports.checkContentType = checkContentType;
+// export function checkContentType(url: string) {
+//     return new Promise((resolve, reject) => {
+//         // Making a HTTP HEAD request to get only the headers
+//         type ReturnVal = { valid?: boolean, contentType?: string | null, extension?: string, embed?: boolean, method?: string};
+//         let returnVal: ReturnVal = {valid: false};
+//         function fetchUrl(method: string) {
+//             fetch(url, { method: method })
+//                 .then(response => {
+//                     if (!response.ok) {
+//                         returnVal.valid = false                    
+//                     } 
+//                     else if (response.status === 200) {
+//                         const contentType = response.headers.get('content-type');
+//                         if (!contentType) {
+//                             return fetchUrl('GET')
+//                         } else {
+//                             let extension = getFileExtensionFromMimeType(contentType)
+//                             returnVal.valid = true
+//                             returnVal.contentType = contentType
+//                             returnVal.extension = extension 
+//                             returnVal.method = method
+//                             returnVal.embed = !isValidDirect(extension)
+//                             console.log('Content-Type:', contentType);
+//                         }
+//                     } 
+//                     return resolve(returnVal);
+//                 })
+//                 .catch(error => {
+//                     console.error('Error while fetching URL:', error);
+//                     resolve(returnVal);
+//                 });                
+//         }
+//         try {
+//             fetchUrl('HEAD');
+//         } catch (error) {
+//         }
+//     });
+// }
 function isValidDirect(extension) {
     switch (extension) {
         case '.png':

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "emblem-vault-sdk",
-  "version": "1.10.0",
+  "version": "1.10.2",
   "description": "Emblem Vault Software Development Kit",
   "main": "dist/index.js",
   "scripts": {

package/src/utils.ts

@@ -568,35 +568,94 @@ export async function getLegacyContract(web3: any) {
 
 export function checkContentType(url: string) {
     return new Promise((resolve, reject) => {
-        // Making a HTTP HEAD request to get only the headers
-        type ReturnVal = { valid?: boolean, contentType?: string | null, extension?: string, embed?: boolean };
-        let returnVal: ReturnVal = {valid: false};
-        try {
-            fetch(url, { method: 'HEAD' })
+        // Define the return value type
+        type ReturnVal = { valid?: boolean, contentType?: string | null, extension?: string, embed?: boolean, method?: string };
+        let returnVal: ReturnVal = { valid: false };
+
+        // Function to make fetch requests
+        function fetchUrl(method: string): any {
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), 3000); // 3 seconds timeout (probably need to make this timeout only for HEAD)
+
+            return fetch(url, { method: method, signal: controller.signal })
                 .then(response => {
+                    clearTimeout(timeoutId);
                     if (!response.ok) {
-                        returnVal.valid = false                    
-                    } 
-                    else if (response.status === 200) {
+                        returnVal.valid = false;
+                        return resolve(returnVal);
+                    } else if (response.status === 200) {
                         const contentType = response.headers.get('content-type');
-                        let extension = getFileExtensionFromMimeType(contentType)
-                        returnVal.valid = true
-                        returnVal.contentType = contentType
-                        returnVal.extension = extension 
-                        returnVal.embed = !isValidDirect(extension)
-                        console.log('Content-Type:', contentType);
-                    } 
-                    resolve(returnVal);
+                        if (!contentType && method === 'HEAD') {
+                            // If content-type is not found in HEAD, make a GET request
+                            return fetchUrl('GET');
+                        } else {
+                            // Process the content type and resolve the promise
+                            let extension = getFileExtensionFromMimeType(contentType);
+                            returnVal.valid = true;
+                            returnVal.contentType = contentType;
+                            returnVal.extension = extension;
+                            returnVal.method = method;
+                            returnVal.embed = !isValidDirect(extension);
+                            console.log('Content-Type:', contentType);
+                            return resolve(returnVal);
+                        }
+                    } else {
+                        return resolve(returnVal);
+                    }
                 })
                 .catch(error => {
+                    clearTimeout(timeoutId);
                     console.error('Error while fetching URL:', error);
-                    resolve(returnVal);
+                    return resolve(returnVal);
                 });
-            } catch (error) {
+        }
 
-            }
+        // Start with a HEAD request
+        fetchUrl('HEAD').catch((error: any) => {
+            console.error('Initial fetch error:', error);
+            resolve(returnVal);
+        });
     });
 }
+// export function checkContentType(url: string) {
+//     return new Promise((resolve, reject) => {
+//         // Making a HTTP HEAD request to get only the headers
+//         type ReturnVal = { valid?: boolean, contentType?: string | null, extension?: string, embed?: boolean, method?: string};
+//         let returnVal: ReturnVal = {valid: false};
+//         function fetchUrl(method: string) {
+//             fetch(url, { method: method })
+//                 .then(response => {
+//                     if (!response.ok) {
+//                         returnVal.valid = false                    
+//                     } 
+//                     else if (response.status === 200) {
+//                         const contentType = response.headers.get('content-type');
+//                         if (!contentType) {
+//                             return fetchUrl('GET')
+//                         } else {
+//                             let extension = getFileExtensionFromMimeType(contentType)
+//                             returnVal.valid = true
+//                             returnVal.contentType = contentType
+//                             returnVal.extension = extension 
+//                             returnVal.method = method
+//                             returnVal.embed = !isValidDirect(extension)
+//                             console.log('Content-Type:', contentType);
+//                         }
+//                     } 
+//                     return resolve(returnVal);
+//                 })
+//                 .catch(error => {
+//                     console.error('Error while fetching URL:', error);
+//                     resolve(returnVal);
+//                 });                
+//         }
+//         try {
+//             fetchUrl('HEAD');
+//         } catch (error) {
+
+//         }
+//     });
+// }
 
 function isValidDirect(extension: string) {
     switch (extension) {