@aws-amplify/predictions 5.5.6-api-v6-models.b3abc9b.0 → 6.0.0

package/lib/providers/AmazonAIInterpretPredictionsProvider.js

@@ -0,0 +1,208 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AmazonAIInterpretPredictionsProvider = void 0;
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+const core_1 = require("@aws-amplify/core");
+const utils_1 = require("@aws-amplify/core/internals/utils");
+const client_comprehend_1 = require("@aws-sdk/client-comprehend");
+const validation_1 = require("../errors/types/validation");
+const assertValidationError_1 = require("../errors/utils/assertValidationError");
+const types_1 = require("../types");
+class AmazonAIInterpretPredictionsProvider {
+    getProviderName() {
+        return 'AmazonAIInterpretPredictionsProvider';
+    }
+    interpret(input) {
+        (0, assertValidationError_1.assertValidationError)((0, types_1.isValidInterpretInput)(input), validation_1.PredictionsValidationErrorCode.InvalidInput);
+        return this.interpretText(input);
+    }
+    async interpretText(input) {
+        const { credentials } = await (0, core_1.fetchAuthSession)();
+        (0, assertValidationError_1.assertValidationError)(!!credentials, validation_1.PredictionsValidationErrorCode.NoCredentials);
+        const { interpretText = {} } = core_1.Amplify.getConfig().Predictions?.interpret ?? {};
+        const { region = '', defaults = {} } = interpretText;
+        const { type: defaultType = '' } = defaults;
+        const { text: textSource } = input;
+        const { source, type = defaultType } = textSource;
+        const { text } = source;
+        let language;
+        if ((0, types_1.isInterpretTextOthers)(textSource)) {
+            language = textSource.source.language;
+        }
+        this.comprehendClient = new client_comprehend_1.ComprehendClient({
+            credentials,
+            region,
+            customUserAgent: (0, utils_1.getAmplifyUserAgentObject)({
+                category: utils_1.Category.Predictions,
+                action: utils_1.PredictionsAction.Interpret,
+            }),
+        });
+        const doAll = type === 'all';
+        let languageCode = language;
+        if (doAll || type === 'language') {
+            const languageDetectionParams = {
+                Text: text,
+            };
+            languageCode = await this.detectLanguage(languageDetectionParams);
+        }
+        let entitiesPromise;
+        if (doAll || type === 'entities') {
+            (0, assertValidationError_1.assertValidationError)(!!languageCode, validation_1.PredictionsValidationErrorCode.NoLanguage);
+            const entitiesDetectionParams = {
+                Text: text,
+                LanguageCode: languageCode,
+            };
+            entitiesPromise = this.detectEntities(entitiesDetectionParams);
+        }
+        let sentimentPromise;
+        if (doAll || type === 'sentiment') {
+            (0, assertValidationError_1.assertValidationError)(!!languageCode, validation_1.PredictionsValidationErrorCode.NoLanguage);
+            const sentimentParams = {
+                Text: text,
+                LanguageCode: languageCode,
+            };
+            sentimentPromise = this.detectSentiment(sentimentParams);
+        }
+        let syntaxPromise;
+        if (doAll || type === 'syntax') {
+            (0, assertValidationError_1.assertValidationError)(!!languageCode, validation_1.PredictionsValidationErrorCode.NoLanguage);
+            const syntaxParams = {
+                Text: text,
+                LanguageCode: languageCode,
+            };
+            syntaxPromise = this.detectSyntax(syntaxParams);
+        }
+        let keyPhrasesPromise;
+        if (doAll || type === 'keyPhrases') {
+            (0, assertValidationError_1.assertValidationError)(!!languageCode, validation_1.PredictionsValidationErrorCode.NoLanguage);
+            const keyPhrasesParams = {
+                Text: text,
+                LanguageCode: languageCode,
+            };
+            keyPhrasesPromise = this.detectKeyPhrases(keyPhrasesParams);
+        }
+        const [textEntities, sentiment, syntax, keyPhrases] = await Promise.all([
+            entitiesPromise,
+            sentimentPromise,
+            syntaxPromise,
+            keyPhrasesPromise,
+        ]);
+        return {
+            textInterpretation: {
+                keyPhrases,
+                language: languageCode,
+                sentiment,
+                syntax,
+                textEntities,
+            },
+        };
+    }
+    async detectKeyPhrases(params) {
+        try {
+            const detectKeyPhrasesCommand = new client_comprehend_1.DetectKeyPhrasesCommand(params);
+            const data = await this.comprehendClient.send(detectKeyPhrasesCommand);
+            const { KeyPhrases = [] } = data || {};
+            return KeyPhrases.map(({ Text: text }) => {
+                return { text };
+            });
+        }
+        catch (err) {
+            if (err.code === 'AccessDeniedException') {
+                throw new Error('Not authorized, did you enable Interpret Text on predictions category Amplify CLI? try: ' +
+                    'amplify predictions add');
+            }
+            else {
+                throw err;
+            }
+        }
+    }
+    async detectSyntax(params) {
+        try {
+            const detectSyntaxCommand = new client_comprehend_1.DetectSyntaxCommand(params);
+            const data = await this.comprehendClient.send(detectSyntaxCommand);
+            const { SyntaxTokens = [] } = data || {};
+            return this.serializeSyntaxFromComprehend(SyntaxTokens);
+        }
+        catch (err) {
+            if (err.code === 'AccessDeniedException') {
+                throw new Error('Not authorized, did you enable Interpret Text on predictions category Amplify CLI? try: ' +
+                    'amplify predictions add');
+            }
+            else {
+                throw err;
+            }
+        }
+    }
+    serializeSyntaxFromComprehend(tokens) {
+        let response = [];
+        if (tokens && Array.isArray(tokens)) {
+            response = tokens.map(({ Text: text = '', PartOfSpeech: { Tag: syntax = '' } = {} }) => {
+                return { text, syntax };
+            });
+        }
+        return response;
+    }
+    async detectSentiment(params) {
+        try {
+            const detectSentimentCommand = new client_comprehend_1.DetectSentimentCommand(params);
+            const data = await this.comprehendClient.send(detectSentimentCommand);
+            const { Sentiment: predominant = '', SentimentScore: { Positive: positive = 0, Negative: negative = 0, Neutral: neutral = 0, Mixed: mixed = 0, } = {}, } = ({} = data);
+            return { predominant, positive, negative, neutral, mixed };
+        }
+        catch (err) {
+            if (err.code === 'AccessDeniedException') {
+                throw new Error('Not authorized, did you enable Interpret Text on predictions category Amplify CLI? try: ' +
+                    'amplify predictions add');
+            }
+            else {
+                throw err;
+            }
+        }
+    }
+    async detectEntities(params) {
+        try {
+            const detectEntitiesCommand = new client_comprehend_1.DetectEntitiesCommand(params);
+            const data = await this.comprehendClient.send(detectEntitiesCommand);
+            const { Entities = [] } = data || {};
+            return this.serializeEntitiesFromComprehend(Entities);
+        }
+        catch (err) {
+            if (err.code === 'AccessDeniedException') {
+                throw new Error('Not authorized, did you enable Interpret Text on predictions category Amplify CLI? try: ' +
+                    'amplify predictions add');
+            }
+            else {
+                throw err;
+            }
+        }
+    }
+    serializeEntitiesFromComprehend(data) {
+        let response = [];
+        if (data && Array.isArray(data)) {
+            response = data.map(({ Type: type, Text: text }) => {
+                return { type, text };
+            });
+        }
+        return response;
+    }
+    async detectLanguage(params) {
+        try {
+            const detectDominantLanguageCommand = new client_comprehend_1.DetectDominantLanguageCommand(params);
+            const data = await this.comprehendClient.send(detectDominantLanguageCommand);
+            const { Languages: [{ LanguageCode }] = [{}] } = ({} = data || {});
+            (0, assertValidationError_1.assertValidationError)(!!LanguageCode, validation_1.PredictionsValidationErrorCode.NoLanguage);
+            return LanguageCode;
+        }
+        catch (err) {
+            if (err.code === 'AccessDeniedException') {
+                throw new Error('Not authorized, did you enable Interpret Text on predictions category Amplify CLI? try: ' +
+                    'amplify predictions add');
+            }
+            else {
+                throw err;
+            }
+        }
+    }
+}
+exports.AmazonAIInterpretPredictionsProvider = AmazonAIInterpretPredictionsProvider;

package/lib/providers/IdentifyTextUtils.d.ts

@@ -0,0 +1,16 @@
+import { IdentifyTextOutput } from '../types';
+import { BlockList, TextDetectionList } from '../types/AWSTypes';
+/**
+ * Organizes blocks from Rekognition API to each of the categories and and structures
+ * their data accordingly.
+ * @param {BlockList} source - Array containing blocks returned from Textract API.
+ * @return {IdentifyTextOutput} -  Object that categorizes each block and its information.
+ */
+export declare function categorizeRekognitionBlocks(blocks: TextDetectionList): IdentifyTextOutput;
+/**
+ * Organizes blocks from Textract API to each of the categories and and structures
+ * their data accordingly.
+ * @param {BlockList} source - Array containing blocks returned from Textract API.
+ * @return {IdentifyTextOutput} -  Object that categorizes each block and its information.
+ */
+export declare function categorizeTextractBlocks(blocks: BlockList): IdentifyTextOutput;

package/lib/{Providers → providers}/IdentifyTextUtils.js

@@ -1,16 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var Utils_1 = require("./Utils");
+exports.categorizeTextractBlocks = exports.categorizeRekognitionBlocks = void 0;
+const Utils_1 = require("./Utils");
 function getBoundingBox(geometry) {
-    if (!geometry)
-        return undefined;
-    return Utils_1.makeCamelCase(geometry.BoundingBox);
+    return (0, Utils_1.makeCamelCase)(geometry?.BoundingBox);
 }
 function getPolygon(geometry) {
-    if (!geometry)
+    if (!geometry?.Polygon)
         return undefined;
-    return Utils_1.makeCamelCaseArray(Array.from(geometry.Polygon));
+    return (0, Utils_1.makeCamelCaseArray)(Array.from(geometry.Polygon));
 }
 /**
  * Organizes blocks from Rekognition API to each of the categories and and structures
@@ -20,7 +18,7 @@ function getPolygon(geometry) {
  */
 function categorizeRekognitionBlocks(blocks) {
     // Skeleton IdentifyText API response. We will populate it as we iterate through blocks.
-    var response = {
+    const response = {
         text: {
             fullText: '',
             words: [],
@@ -29,15 +27,17 @@ function categorizeRekognitionBlocks(blocks) {
         },
     };
     // We categorize each block by running a forEach loop through them.
-    blocks.forEach(function (block) {
+    blocks.forEach(block => {
         switch (block.Type) {
             case 'LINE':
-                response.text.lines.push(block.DetectedText);
+                if (block.DetectedText) {
+                    response.text.lines.push(block.DetectedText);
+                }
                 response.text.linesDetailed.push({
                     text: block.DetectedText,
                     polygon: getPolygon(block.Geometry),
                     boundingBox: getBoundingBox(block.Geometry),
-                    page: null,
+                    page: undefined, // rekognition doesn't have this info
                 });
                 break;
             case 'WORD':
@@ -63,7 +63,7 @@ exports.categorizeRekognitionBlocks = categorizeRekognitionBlocks;
  */
 function categorizeTextractBlocks(blocks) {
     // Skeleton IdentifyText API response. We will populate it as we iterate through blocks.
-    var response = {
+    const response = {
         text: {
             fullText: '',
             words: [],
@@ -84,13 +84,15 @@ function categorizeTextractBlocks(blocks) {
      * Note that we do not map `WORD` and `TABLE` in `blockMap` because they will not be referenced by any other
      * block except the Page block.
      */
-    var tableBlocks = Array();
-    var keyValueBlocks = Array();
-    var blockMap = {};
-    blocks.forEach(function (block) {
+    const tableBlocks = Array();
+    const keyValueBlocks = Array();
+    const blockMap = {};
+    blocks.forEach(block => {
         switch (block.BlockType) {
             case 'LINE':
-                response.text.lines.push(block.Text);
+                if (block.Text) {
+                    response.text.lines.push(block.Text);
+                }
                 response.text.linesDetailed.push({
                     text: block.Text,
                     polygon: getPolygon(block.Geometry),
@@ -105,10 +107,12 @@ function categorizeTextractBlocks(blocks) {
                     polygon: getPolygon(block.Geometry),
                     boundingBox: getBoundingBox(block.Geometry),
                 });
-                blockMap[block.Id] = block;
+                if (block.Id) {
+                    blockMap[block.Id] = block;
+                }
                 break;
             case 'SELECTION_ELEMENT':
-                var selectionStatus = block.SelectionStatus === 'SELECTED' ? true : false;
+                const selectionStatus = block.SelectionStatus === 'SELECTED' ? true : false;
                 if (!response.text.selections)
                     response.text.selections = [];
                 response.text.selections.push({
@@ -116,39 +120,47 @@ function categorizeTextractBlocks(blocks) {
                     polygon: getPolygon(block.Geometry),
                     boundingBox: getBoundingBox(block.Geometry),
                 });
-                blockMap[block.Id] = block;
+                if (block.Id) {
+                    blockMap[block.Id] = block;
+                }
                 break;
             case 'TABLE':
                 tableBlocks.push(block);
                 break;
             case 'KEY_VALUE_SET':
                 keyValueBlocks.push(block);
-                blockMap[block.Id] = block;
+                if (block.Id) {
+                    blockMap[block.Id] = block;
+                }
                 break;
             default:
-                blockMap[block.Id] = block;
+                if (block.Id) {
+                    blockMap[block.Id] = block;
+                }
         }
     });
     // remove trailing space in fullText
     response.text.fullText = response.text.fullText.substr(0, response.text.fullText.length - 1);
     // Post-process complex structures if they exist.
     if (tableBlocks.length !== 0) {
-        var tableResponse_1 = Array();
-        tableBlocks.forEach(function (table) {
-            tableResponse_1.push(constructTable(table, blockMap));
+        const tableResponse = Array();
+        tableBlocks.forEach(table => {
+            tableResponse.push(constructTable(table, blockMap));
         });
-        response.text.tables = tableResponse_1;
+        response.text.tables = tableResponse;
     }
     if (keyValueBlocks.length !== 0) {
-        var keyValueResponse_1 = Array();
-        keyValueBlocks.forEach(function (keyValue) {
+        const keyValueResponse = Array();
+        keyValueBlocks.forEach(keyValue => {
             // We need the KeyValue blocks of EntityType = `KEY`, which has both key and value references.
-            var entityTypes = Array.from(keyValue.EntityTypes);
-            if (entityTypes.indexOf('KEY') !== -1) {
-                keyValueResponse_1.push(constructKeyValue(keyValue, blockMap));
+            if (keyValue.EntityTypes) {
+                const entityTypes = Array.from(keyValue.EntityTypes);
+                if (entityTypes.indexOf('KEY') !== -1) {
+                    keyValueResponse.push(constructKeyValue(keyValue, blockMap));
+                }
             }
         });
-        response.text.keyValues = keyValueResponse_1;
+        response.text.keyValues = keyValueResponse;
     }
     return response;
 }
@@ -159,107 +171,68 @@ exports.categorizeTextractBlocks = categorizeTextractBlocks;
  * @param {[id: string]: Block} blockMap - Maps block Ids to blocks.
  */
 function constructTable(table, blockMap) {
-    var e_1, _a, e_2, _b;
-    var tableMatrix;
+    let tableMatrix;
     tableMatrix = [];
-    try {
-        // visit each of the cell associated with the table's relationship.
-        for (var _c = tslib_1.__values(table.Relationships), _d = _c.next(); !_d.done; _d = _c.next()) {
-            var tableRelation = _d.value;
-            try {
-                for (var _e = (e_2 = void 0, tslib_1.__values(tableRelation.Ids)), _f = _e.next(); !_f.done; _f = _e.next()) {
-                    var cellId = _f.value;
-                    var cellBlock = blockMap[cellId];
-                    var row = cellBlock.RowIndex - 1; // textract starts indexing at 1, so subtract it by 1.
-                    var col = cellBlock.ColumnIndex - 1; // textract starts indexing at 1, so subtract it by 1.
-                    // extract data contained inside the cell.
-                    var content = extractContentsFromBlock(cellBlock, blockMap);
-                    var cell = {
-                        text: content.text,
-                        boundingBox: getBoundingBox(cellBlock.Geometry),
-                        polygon: getPolygon(cellBlock.Geometry),
-                        selected: content.selected,
-                        rowSpan: cellBlock.RowSpan,
-                        columnSpan: cellBlock.ColumnSpan,
-                    };
-                    if (!tableMatrix[row])
-                        tableMatrix[row] = [];
-                    tableMatrix[row][col] = cell;
-                }
-            }
-            catch (e_2_1) { e_2 = { error: e_2_1 }; }
-            finally {
-                try {
-                    if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
-                }
-                finally { if (e_2) throw e_2.error; }
+    // visit each of the cell associated with the table's relationship.
+    for (const tableRelation of table.Relationships ?? []) {
+        for (const cellId of tableRelation.Ids ?? []) {
+            const cellBlock = blockMap[cellId];
+            if (cellBlock.RowIndex && cellBlock.ColumnIndex) {
+                const row = cellBlock.RowIndex - 1; // textract starts indexing at 1, so subtract it by 1.
+                const col = cellBlock.ColumnIndex - 1; // textract starts indexing at 1, so subtract it by 1.
+                // extract data contained inside the cell.
+                const content = extractContentsFromBlock(cellBlock, blockMap);
+                const cell = {
+                    text: content.text,
+                    boundingBox: getBoundingBox(cellBlock.Geometry),
+                    polygon: getPolygon(cellBlock.Geometry),
+                    selected: content.selected,
+                    rowSpan: cellBlock.RowSpan,
+                    columnSpan: cellBlock.ColumnSpan,
+                };
+                if (!tableMatrix[row])
+                    tableMatrix[row] = [];
+                tableMatrix[row][col] = cell;
             }
         }
     }
-    catch (e_1_1) { e_1 = { error: e_1_1 }; }
-    finally {
-        try {
-            if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
-        }
-        finally { if (e_1) throw e_1.error; }
-    }
-    var rowSize = tableMatrix.length;
-    var columnSize = tableMatrix[0].length;
+    const rowSize = tableMatrix.length;
+    const columnSize = tableMatrix[0].length;
+    const boundingBox = getBoundingBox(table.Geometry);
+    const polygon = getPolygon(table.Geometry);
     // Note that we leave spanned cells undefined for distinction
     return {
         size: { rows: rowSize, columns: columnSize },
         table: tableMatrix,
-        boundingBox: getBoundingBox(table.Geometry),
-        polygon: getPolygon(table.Geometry),
+        boundingBox,
+        polygon,
     };
 }
-exports.constructTable = constructTable;
 /**
  * Constructs a key value object from its children key and value blocks.
  * @param {Block} KeyValue - KeyValue block that has references (`Relationships`) to its children.
  * @param {[id: string]: Block} blockMap - Maps block Ids to blocks.
  */
 function constructKeyValue(keyBlock, blockMap) {
-    var e_3, _a, e_4, _b;
-    var keyText = '';
-    var valueText = '';
-    var valueSelected;
-    try {
-        for (var _c = tslib_1.__values(keyBlock.Relationships), _d = _c.next(); !_d.done; _d = _c.next()) {
-            var keyValueRelation = _d.value;
-            if (keyValueRelation.Type === 'CHILD') {
-                // relation refers to key
-                var contents = extractContentsFromBlock(keyBlock, blockMap);
-                keyText = contents.text;
-            }
-            else if (keyValueRelation.Type === 'VALUE') {
-                try {
-                    // relation refers to value
-                    for (var _e = (e_4 = void 0, tslib_1.__values(keyValueRelation.Ids)), _f = _e.next(); !_f.done; _f = _e.next()) {
-                        var valueId = _f.value;
-                        var valueBlock = blockMap[valueId];
-                        var contents = extractContentsFromBlock(valueBlock, blockMap);
-                        valueText = contents.text;
-                        if (contents.selected != null)
-                            valueSelected = contents.selected;
-                    }
-                }
-                catch (e_4_1) { e_4 = { error: e_4_1 }; }
-                finally {
-                    try {
-                        if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
-                    }
-                    finally { if (e_4) throw e_4.error; }
-                }
-            }
+    let keyText = '';
+    let valueText = '';
+    let valueSelected = false;
+    for (const keyValueRelation of keyBlock.Relationships ?? []) {
+        if (keyValueRelation.Type === 'CHILD') {
+            // relation refers to key
+            const contents = extractContentsFromBlock(keyBlock, blockMap);
+            keyText = contents.text ?? '';
         }
-    }
-    catch (e_3_1) { e_3 = { error: e_3_1 }; }
-    finally {
-        try {
-            if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+        else if (keyValueRelation.Type === 'VALUE') {
+            // relation refers to value
+            for (const valueId of keyValueRelation.Ids ?? []) {
+                const valueBlock = blockMap[valueId];
+                const contents = extractContentsFromBlock(valueBlock, blockMap);
+                valueText = contents.text ?? '';
+                if (contents.selected != null)
+                    valueSelected = contents.selected;
+            }
         }
-        finally { if (e_3) throw e_3.error; }
     }
     return {
         key: keyText,
@@ -268,53 +241,29 @@ function constructKeyValue(keyBlock, blockMap) {
         boundingBox: getBoundingBox(keyBlock.Geometry),
     };
 }
-exports.constructKeyValue = constructKeyValue;
 /**
  * Extracts text and selection from input block's children.
  * @param {Block}} block - Block that we want to extract contents from.
  * @param {[id: string]: Block} blockMap - Maps block Ids to blocks.
  */
 function extractContentsFromBlock(block, blockMap) {
-    var e_5, _a, e_6, _b;
-    var words = '';
-    var isSelected;
+    let words = '';
+    let isSelected = false;
     if (!block.Relationships) {
         // some block might have no content
         return { text: '', selected: undefined };
     }
-    try {
-        for (var _c = tslib_1.__values(block.Relationships), _d = _c.next(); !_d.done; _d = _c.next()) {
-            var relation = _d.value;
-            try {
-                for (var _e = (e_6 = void 0, tslib_1.__values(relation.Ids)), _f = _e.next(); !_f.done; _f = _e.next()) {
-                    var contentId = _f.value;
-                    var contentBlock = blockMap[contentId];
-                    if (contentBlock.BlockType === 'WORD') {
-                        words += contentBlock.Text + ' ';
-                    }
-                    else if (contentBlock.BlockType === 'SELECTION_ELEMENT') {
-                        isSelected = contentBlock.SelectionStatus === 'SELECTED' ? true : false;
-                    }
-                }
+    for (const relation of block.Relationships) {
+        for (const contentId of relation.Ids ?? []) {
+            const contentBlock = blockMap[contentId];
+            if (contentBlock.BlockType === 'WORD') {
+                words += contentBlock.Text + ' ';
             }
-            catch (e_6_1) { e_6 = { error: e_6_1 }; }
-            finally {
-                try {
-                    if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
-                }
-                finally { if (e_6) throw e_6.error; }
+            else if (contentBlock.BlockType === 'SELECTION_ELEMENT') {
+                isSelected = contentBlock.SelectionStatus === 'SELECTED' ? true : false;
             }
         }
     }
-    catch (e_5_1) { e_5 = { error: e_5_1 }; }
-    finally {
-        try {
-            if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
-        }
-        finally { if (e_5) throw e_5.error; }
-    }
     words = words.substr(0, words.length - 1); // remove trailing space.
     return { text: words, selected: isSelected };
 }
-exports.extractContentsFromBlock = extractContentsFromBlock;
-//# sourceMappingURL=IdentifyTextUtils.js.map

package/lib/{Providers → providers}/Utils.d.ts

@@ -2,11 +2,11 @@
  * Changes object keys to camel case. If optional parameter `keys` is given, then we extract only the
  * keys specified in `keys`.
  */
-export declare function makeCamelCase(obj: object, keys?: string[]): {};
+export declare function makeCamelCase(obj?: any, keys?: string[]): {} | undefined;
 /**
  * Given an array of object, call makeCamelCase(...) on each option.
  */
-export declare function makeCamelCaseArray(objArr: object[], keys?: string[]): {}[];
+export declare function makeCamelCaseArray(objArr?: object[], keys?: string[]): ({} | undefined)[] | undefined;
 /**
  * Converts blob to array buffer
  */

package/lib/{Providers → providers}/Utils.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.blobToArrayBuffer = exports.makeCamelCaseArray = exports.makeCamelCase = void 0;
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 /**
@@ -9,14 +10,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 function makeCamelCase(obj, keys) {
     if (!obj)
         return undefined;
-    var newObj = {};
-    var keysToRename = keys ? keys : Object.keys(obj);
-    keysToRename.forEach(function (key) {
-        var _a;
+    const newObj = {};
+    const keysToRename = keys ? keys : Object.keys(obj);
+    keysToRename.forEach(key => {
         if (obj.hasOwnProperty(key)) {
             // change the key to camelcase.
-            var camelCaseKey = key.charAt(0).toLowerCase() + key.substr(1);
-            Object.assign(newObj, (_a = {}, _a[camelCaseKey] = obj[key], _a));
+            const camelCaseKey = key.charAt(0).toLowerCase() + key.substr(1);
+            Object.assign(newObj, { [camelCaseKey]: obj[key] });
         }
     });
     return newObj;
@@ -28,19 +28,19 @@ exports.makeCamelCase = makeCamelCase;
 function makeCamelCaseArray(objArr, keys) {
     if (!objArr)
         return undefined;
-    return objArr.map(function (obj) { return makeCamelCase(obj, keys); });
+    return objArr.map(obj => makeCamelCase(obj, keys));
 }
 exports.makeCamelCaseArray = makeCamelCaseArray;
 /**
  * Converts blob to array buffer
  */
 function blobToArrayBuffer(blob) {
-    return new Promise(function (res, rej) {
-        var reader = new FileReader();
-        reader.onload = function (_event) {
+    return new Promise((res, rej) => {
+        const reader = new FileReader();
+        reader.onload = _event => {
             res(reader.result);
         };
-        reader.onerror = function (err) {
+        reader.onerror = err => {
             rej(err);
         };
         try {
@@ -52,4 +52,3 @@ function blobToArrayBuffer(blob) {
     });
 }
 exports.blobToArrayBuffer = blobToArrayBuffer;
-//# sourceMappingURL=Utils.js.map