cloudstructs 0.12.8 → 0.12.10

package/node_modules/strnum/strnum.js

@@ -3,103 +3,106 @@ const numRegex = /^([\-\+])?(0*)([0-9]*(\.[0-9]*)?)$/;
 // const octRegex = /^0x[a-z0-9]+/;
 // const binRegex = /0x[a-z0-9]+/;
 
- 
+
 const consider = {
-    hex :  true,
+    hex: true,
     // oct: false,
     leadingZeros: true,
     decimalPoint: "\.",
     eNotation: true,
-    //skipLike: /regex/
+    //skipLike: /regex/,
+    infinity: "original", // "null", "infinity" (Infinity type), "string" ("Infinity" (the string literal))
 };
 
-export default function toNumber(str, options = {}){
-    options = Object.assign({}, consider, options );
-    if(!str || typeof str !== "string" ) return str;
-    
-    let trimmedStr  = str.trim();
-    
-    if(options.skipLike !== undefined && options.skipLike.test(trimmedStr)) return str;
-    else if(str==="0") return 0;
+export default function toNumber(str, options = {}) {
+    options = Object.assign({}, consider, options);
+    if (!str || typeof str !== "string") return str;
+
+    let trimmedStr = str.trim();
+
+    if (options.skipLike !== undefined && options.skipLike.test(trimmedStr)) return str;
+    else if (str === "0") return 0;
     else if (options.hex && hexRegex.test(trimmedStr)) {
         return parse_int(trimmedStr, 16);
-    // }else if (options.oct && octRegex.test(str)) {
-    //     return Number.parseInt(val, 8);
-    }else if (trimmedStr.includes('e') || trimmedStr.includes('E')) { //eNotation
-        return resolveEnotation(str,trimmedStr,options);
-    // }else if (options.parseBin && binRegex.test(str)) {
-    //     return Number.parseInt(val, 2);
-    }else{
+        // }else if (options.oct && octRegex.test(str)) {
+        //     return Number.parseInt(val, 8);
+    } else if (!isFinite(trimmedStr)) { //Infinity
+        return handleInfinity(str, Number(trimmedStr), options);
+    } else if (trimmedStr.includes('e') || trimmedStr.includes('E')) { //eNotation
+        return resolveEnotation(str, trimmedStr, options);
+        // }else if (options.parseBin && binRegex.test(str)) {
+        //     return Number.parseInt(val, 2);
+    } else {
         //separate negative sign, leading zeros, and rest number
         const match = numRegex.exec(trimmedStr);
         // +00.123 => [ , '+', '00', '.123', ..
-        if(match){
+        if (match) {
             const sign = match[1] || "";
             const leadingZeros = match[2];
             let numTrimmedByZeros = trimZeros(match[3]); //complete num without leading zeros
             const decimalAdjacentToLeadingZeros = sign ? // 0., -00., 000.
-                str[leadingZeros.length+1] === "." 
+                str[leadingZeros.length + 1] === "."
                 : str[leadingZeros.length] === ".";
 
             //trim ending zeros for floating number
-            if(!options.leadingZeros //leading zeros are not allowed
-                && (leadingZeros.length > 1 
-                    || (leadingZeros.length === 1 && !decimalAdjacentToLeadingZeros))){
+            if (!options.leadingZeros //leading zeros are not allowed
+                && (leadingZeros.length > 1
+                    || (leadingZeros.length === 1 && !decimalAdjacentToLeadingZeros))) {
                 // 00, 00.3, +03.24, 03, 03.24
                 return str;
             }
-            else{//no leading zeros or leading zeros are allowed
+            else {//no leading zeros or leading zeros are allowed
                 const num = Number(trimmedStr);
                 const parsedStr = String(num);
 
-                if( num === 0) return num;
-                if(parsedStr.search(/[eE]/) !== -1){ //given number is long and parsed to eNotation
-                    if(options.eNotation) return num;
+                if (num === 0) return num;
+                if (parsedStr.search(/[eE]/) !== -1) { //given number is long and parsed to eNotation
+                    if (options.eNotation) return num;
                     else return str;
-                }else if(trimmedStr.indexOf(".") !== -1){ //floating number
-                    if(parsedStr === "0") return num; //0.0
-                    else if(parsedStr === numTrimmedByZeros) return num; //0.456. 0.79000
-                    else if( parsedStr === `${sign}${numTrimmedByZeros}`) return num;
+                } else if (trimmedStr.indexOf(".") !== -1) { //floating number
+                    if (parsedStr === "0") return num; //0.0
+                    else if (parsedStr === numTrimmedByZeros) return num; //0.456. 0.79000
+                    else if (parsedStr === `${sign}${numTrimmedByZeros}`) return num;
                     else return str;
                 }
-                
-                let n = leadingZeros? numTrimmedByZeros : trimmedStr;
-                if(leadingZeros){
+
+                let n = leadingZeros ? numTrimmedByZeros : trimmedStr;
+                if (leadingZeros) {
                     // -009 => -9
-                    return (n === parsedStr) || (sign+n === parsedStr) ? num : str
-                }else  {
+                    return (n === parsedStr) || (sign + n === parsedStr) ? num : str
+                } else {
                     // +9
-                    return (n === parsedStr) || (n === sign+parsedStr) ? num : str
+                    return (n === parsedStr) || (n === sign + parsedStr) ? num : str
                 }
             }
-        }else{ //non-numeric string
+        } else { //non-numeric string
             return str;
         }
     }
 }
 
 const eNotationRegx = /^([-+])?(0*)(\d*(\.\d*)?[eE][-\+]?\d+)$/;
-function resolveEnotation(str,trimmedStr,options){
-    if(!options.eNotation) return str;
-    const notation = trimmedStr.match(eNotationRegx); 
-    if(notation){
+function resolveEnotation(str, trimmedStr, options) {
+    if (!options.eNotation) return str;
+    const notation = trimmedStr.match(eNotationRegx);
+    if (notation) {
         let sign = notation[1] || "";
         const eChar = notation[3].indexOf("e") === -1 ? "E" : "e";
         const leadingZeros = notation[2];
         const eAdjacentToLeadingZeros = sign ? // 0E.
-            str[leadingZeros.length+1] === eChar 
+            str[leadingZeros.length + 1] === eChar
             : str[leadingZeros.length] === eChar;
 
-        if(leadingZeros.length > 1 && eAdjacentToLeadingZeros) return str;
-        else if(leadingZeros.length === 1 
-            && (notation[3].startsWith(`.${eChar}`) || notation[3][0] === eChar)){
-                return Number(trimmedStr);
-        }else if(options.leadingZeros && !eAdjacentToLeadingZeros){ //accept with leading zeros
+        if (leadingZeros.length > 1 && eAdjacentToLeadingZeros) return str;
+        else if (leadingZeros.length === 1
+            && (notation[3].startsWith(`.${eChar}`) || notation[3][0] === eChar)) {
+            return Number(trimmedStr);
+        } else if (options.leadingZeros && !eAdjacentToLeadingZeros) { //accept with leading zeros
             //remove leading 0s
             trimmedStr = (notation[1] || "") + notation[3];
             return Number(trimmedStr);
-        }else return str;
-    }else{
+        } else return str;
+    } else {
         return str;
     }
 }
@@ -109,21 +112,44 @@ function resolveEnotation(str,trimmedStr,options){
  * @param {string} numStr without leading zeros
  * @returns 
  */
-function trimZeros(numStr){
-    if(numStr && numStr.indexOf(".") !== -1){//float
+function trimZeros(numStr) {
+    if (numStr && numStr.indexOf(".") !== -1) {//float
         numStr = numStr.replace(/0+$/, ""); //remove ending zeros
-        if(numStr === ".")  numStr = "0";
-        else if(numStr[0] === ".")  numStr = "0"+numStr;
-        else if(numStr[numStr.length-1] === ".")  numStr = numStr.substring(0,numStr.length-1);
+        if (numStr === ".") numStr = "0";
+        else if (numStr[0] === ".") numStr = "0" + numStr;
+        else if (numStr[numStr.length - 1] === ".") numStr = numStr.substring(0, numStr.length - 1);
         return numStr;
     }
     return numStr;
 }
 
-function parse_int(numStr, base){
+function parse_int(numStr, base) {
     //polyfill
-    if(parseInt) return parseInt(numStr, base);
-    else if(Number.parseInt) return Number.parseInt(numStr, base);
-    else if(window && window.parseInt) return window.parseInt(numStr, base);
+    if (parseInt) return parseInt(numStr, base);
+    else if (Number.parseInt) return Number.parseInt(numStr, base);
+    else if (window && window.parseInt) return window.parseInt(numStr, base);
     else throw new Error("parseInt, Number.parseInt, window.parseInt are not supported")
+}
+
+/**
+ * Handle infinite values based on user option
+ * @param {string} str - original input string
+ * @param {number} num - parsed number (Infinity or -Infinity)
+ * @param {object} options - user options
+ * @returns {string|number|null} based on infinity option
+ */
+function handleInfinity(str, num, options) {
+    const isPositive = num === Infinity;
+
+    switch (options.infinity.toLowerCase()) {
+        case "null":
+            return null;
+        case "infinity":
+            return num; // Return Infinity or -Infinity
+        case "string":
+            return isPositive ? "Infinity" : "-Infinity";
+        case "original":
+        default:
+            return str; // Return original string like "1e1000"
+    }
 }

package/node_modules/strnum/tests/infinity_test.js

@@ -0,0 +1,18 @@
+import toNumber from "../strnum.js";
+
+describe("Should convert all the valid numeric strings to number", () => {
+  it("should return infinity as per user option", () => {
+    expect(toNumber("1e1000", { infinity: "original" })).toEqual("1e1000");
+    expect(toNumber("1e1000", { infinity: "null" })).toEqual(null);
+    expect(toNumber("1e1000", { infinity: "infinity" })).toEqual(Infinity);
+    expect(toNumber("1e1000", { infinity: "string" })).toEqual("Infinity");
+    expect(toNumber("-1e1000", { infinity: "original" })).toEqual("-1e1000");
+    expect(toNumber("-1e1000", { infinity: "null" })).toEqual(null);
+    expect(toNumber("-1e1000", { infinity: "infinity" })).toEqual(-Infinity);
+    expect(toNumber("-1e1000", { infinity: "string" })).toEqual("-Infinity");
+
+
+    expect(toNumber("1e309")).toEqual("1e309");
+
+  });
+});

package/node_modules/strnum/{strnum.test.js → tests/strnum_test.js}

@@ -1,4 +1,4 @@
-import toNumber from "./strnum.js";
+import toNumber from "../strnum.js";
 
 describe("Should convert all the valid numeric strings to number", () => {
     it("should return undefined, null, empty string, or non-numeric as it is", () => {
@@ -7,7 +7,6 @@ describe("Should convert all the valid numeric strings to number", () => {
         expect(toNumber("")).toEqual("");
         expect(toNumber("string")).toEqual("string");
         expect(toNumber("e89794659669cb7bb967db73a7ea6889c3891727")).toEqual("e89794659669cb7bb967db73a7ea6889c3891727");
-        
     });
     it("should not parse number with spaces or comma", () => {
         expect(toNumber("12,12")).toEqual("12,12");
@@ -24,10 +23,10 @@ describe("Should convert all the valid numeric strings to number", () => {
     it("should parse hexadecimal values", () => {
         expect(toNumber("0x2f")).toEqual(47);
         expect(toNumber("-0x2f")).toEqual(-47);
-        expect(toNumber("0x2f", { hex :  true})).toEqual(47);
-        expect(toNumber("-0x2f", { hex :  true})).toEqual(-47);
-        expect(toNumber("0x2f", { hex :  false})).toEqual("0x2f");
-        expect(toNumber("-0x2f", { hex :  false})).toEqual("-0x2f");
+        expect(toNumber("0x2f", { hex: true })).toEqual(47);
+        expect(toNumber("-0x2f", { hex: true })).toEqual(-47);
+        expect(toNumber("0x2f", { hex: false })).toEqual("0x2f");
+        expect(toNumber("-0x2f", { hex: false })).toEqual("-0x2f");
     })
     it("should not parse strings with 0x embedded", () => {
         expect(toNumber("0xzz")).toEqual("0xzz");
@@ -40,54 +39,54 @@ describe("Should convert all the valid numeric strings to number", () => {
         expect(toNumber("00")).toEqual(0);
         expect(toNumber("00.0")).toEqual(0);
 
-        expect(toNumber("0",{ leadingZeros :  false})).toEqual(0);
-        expect(toNumber("00",{ leadingZeros :  false})).toEqual("00");
-        expect(toNumber("00.0",{ leadingZeros :  false})).toEqual("00.0");
+        expect(toNumber("0", { leadingZeros: false })).toEqual(0);
+        expect(toNumber("00", { leadingZeros: false })).toEqual("00");
+        expect(toNumber("00.0", { leadingZeros: false })).toEqual("00.0");
 
         expect(toNumber("06")).toEqual(6);
-        expect(toNumber("06", { leadingZeros :  true})).toEqual(6);
-        expect(toNumber("06", { leadingZeros :  false})).toEqual("06");
+        expect(toNumber("06", { leadingZeros: true })).toEqual(6);
+        expect(toNumber("06", { leadingZeros: false })).toEqual("06");
 
         expect(toNumber("006")).toEqual(6);
-        expect(toNumber("006", { leadingZeros :  true})).toEqual(6);
-        expect(toNumber("006", { leadingZeros :  false})).toEqual("006");
+        expect(toNumber("006", { leadingZeros: true })).toEqual(6);
+        expect(toNumber("006", { leadingZeros: false })).toEqual("006");
 
-        expect(toNumber("000000000000000000000000017717"  ,  { leadingZeros :  false})).toEqual("000000000000000000000000017717");
-        expect(toNumber("000000000000000000000000017717"  ,  { leadingZeros :  true})).toEqual(17717);
-        expect(toNumber("020211201030005811824")  ).toEqual("020211201030005811824");
-        expect(toNumber("0420926189200190257681175017717")  ).toEqual(4.209261892001902e+29);
+        expect(toNumber("000000000000000000000000017717", { leadingZeros: false })).toEqual("000000000000000000000000017717");
+        expect(toNumber("000000000000000000000000017717", { leadingZeros: true })).toEqual(17717);
+        expect(toNumber("020211201030005811824")).toEqual("020211201030005811824");
+        expect(toNumber("0420926189200190257681175017717")).toEqual(4.209261892001902e+29);
     })
     it("invalid floating number", () => {
-        expect(toNumber("20.21.030")  ).toEqual("20.21.030");
-        expect(toNumber("0.21.030")  ).toEqual("0.21.030");
-        expect(toNumber("0.21.")  ).toEqual("0.21.");
+        expect(toNumber("20.21.030")).toEqual("20.21.030");
+        expect(toNumber("0.21.030")).toEqual("0.21.030");
+        expect(toNumber("0.21.")).toEqual("0.21.");
     });
     it("floating point and leading zeros", () => {
         expect(toNumber("0.")).toEqual(0);
         expect(toNumber("+0.")).toEqual(0);
         expect(toNumber("-0.")).toEqual(-0);
-        expect(toNumber("1.")  ).toEqual(1);
+        expect(toNumber("1.")).toEqual(1);
         expect(toNumber("00.00")).toEqual(0);
         expect(toNumber("0.06")).toEqual(0.06);
         expect(toNumber("00.6")).toEqual(0.6);
         expect(toNumber(".006")).toEqual(0.006);
         expect(toNumber("6.0")).toEqual(6);
         expect(toNumber("06.0")).toEqual(6);
-        
-        expect(toNumber("0.0",  { leadingZeros :  false})).toEqual(0);
-        expect(toNumber("00.00",  { leadingZeros :  false})).toEqual("00.00");
-        expect(toNumber("0.06",  { leadingZeros :  false})).toEqual(0.06);
-        expect(toNumber("00.6",  { leadingZeros :  false})).toEqual("00.6");
-        expect(toNumber(".006", { leadingZeros :  false})).toEqual(0.006);
-        expect(toNumber("6.0"  ,  { leadingZeros :  false})).toEqual(6);
-        expect(toNumber("06.0"  ,  { leadingZeros :  false})).toEqual("06.0");
+
+        expect(toNumber("0.0", { leadingZeros: false })).toEqual(0);
+        expect(toNumber("00.00", { leadingZeros: false })).toEqual("00.00");
+        expect(toNumber("0.06", { leadingZeros: false })).toEqual(0.06);
+        expect(toNumber("00.6", { leadingZeros: false })).toEqual("00.6");
+        expect(toNumber(".006", { leadingZeros: false })).toEqual(0.006);
+        expect(toNumber("6.0", { leadingZeros: false })).toEqual(6);
+        expect(toNumber("06.0", { leadingZeros: false })).toEqual("06.0");
     })
     it("negative number  leading zeros", () => {
         expect(toNumber("+06")).toEqual(6);
         expect(toNumber("-06")).toEqual(-6);
-        expect(toNumber("-06", { leadingZeros :  true})).toEqual(-6);
-        expect(toNumber("-06", { leadingZeros :  false})).toEqual("-06");
-        
+        expect(toNumber("-06", { leadingZeros: true })).toEqual(-6);
+        expect(toNumber("-06", { leadingZeros: false })).toEqual("-06");
+
         expect(toNumber("-0.0")).toEqual(-0);
         expect(toNumber("-00.00")).toEqual(-0);
         expect(toNumber("-0.06")).toEqual(-0.06);
@@ -96,47 +95,47 @@ describe("Should convert all the valid numeric strings to number", () => {
         expect(toNumber("-6.0")).toEqual(-6);
         expect(toNumber("-06.0")).toEqual(-6);
         expect(toNumber("+06.0")).toEqual(6);
-        
-        expect(toNumber("-0.0"   ,  { leadingZeros :  false})).toEqual(-0);
-        expect(toNumber("-00.00",  { leadingZeros :  false})).toEqual("-00.00");
-        expect(toNumber("-0.06",  { leadingZeros :  false})).toEqual(-0.06);
-        expect(toNumber("-00.6",  { leadingZeros :  false})).toEqual("-00.6");
-        expect(toNumber("-.006",  {leadingZeros :  false})).toEqual(-0.006);
-        expect(toNumber("-6.0"  ,  { leadingZeros :  false})).toEqual(-6);
-        expect(toNumber("-06.0"  ,  { leadingZeros :  false})).toEqual("-06.0");
+
+        expect(toNumber("-0.0", { leadingZeros: false })).toEqual(-0);
+        expect(toNumber("-00.00", { leadingZeros: false })).toEqual("-00.00");
+        expect(toNumber("-0.06", { leadingZeros: false })).toEqual(-0.06);
+        expect(toNumber("-00.6", { leadingZeros: false })).toEqual("-00.6");
+        expect(toNumber("-.006", { leadingZeros: false })).toEqual(-0.006);
+        expect(toNumber("-6.0", { leadingZeros: false })).toEqual(-6);
+        expect(toNumber("-06.0", { leadingZeros: false })).toEqual("-06.0");
     })
     it("long number", () => {
-        expect(toNumber("020211201030005811824")  ).toEqual("020211201030005811824");
-        expect(toNumber("20211201030005811824")  ).toEqual("20211201030005811824");
-        expect(toNumber("20.211201030005811824")  ).toEqual("20.211201030005811824");
-        expect(toNumber("0.211201030005811824")  ).toEqual("0.211201030005811824");
+        expect(toNumber("020211201030005811824")).toEqual("020211201030005811824");
+        expect(toNumber("20211201030005811824")).toEqual("20211201030005811824");
+        expect(toNumber("20.211201030005811824")).toEqual("20.211201030005811824");
+        expect(toNumber("0.211201030005811824")).toEqual("0.211201030005811824");
     });
     it("scientific notation", () => {
-        expect(toNumber("01.0e2"  ,  { leadingZeros :  false})).toEqual("01.0e2");
-        expect(toNumber("-01.0e2"  ,  { leadingZeros :  false})).toEqual("-01.0e2");
-        expect(toNumber("01.0e2") ).toEqual(100);
-        expect(toNumber("-01.0e2") ).toEqual(-100);
-        expect(toNumber("1.0e2") ).toEqual(100);
+        expect(toNumber("01.0e2", { leadingZeros: false })).toEqual("01.0e2");
+        expect(toNumber("-01.0e2", { leadingZeros: false })).toEqual("-01.0e2");
+        expect(toNumber("01.0e2")).toEqual(100);
+        expect(toNumber("-01.0e2")).toEqual(-100);
+        expect(toNumber("1.0e2")).toEqual(100);
 
-        expect(toNumber("-1.0e2") ).toEqual(-100);
+        expect(toNumber("-1.0e2")).toEqual(-100);
         expect(toNumber("1.0e-2")).toEqual(0.01);
-        
-        expect(toNumber("420926189200190257681175017717")  ).toEqual(4.209261892001902e+29);
-        expect(toNumber("420926189200190257681175017717" , { eNotation: false} )).toEqual("420926189200190257681175017717");
-        
+
+        expect(toNumber("420926189200190257681175017717")).toEqual(4.209261892001902e+29);
+        expect(toNumber("420926189200190257681175017717", { eNotation: false })).toEqual("420926189200190257681175017717");
+
         expect(toNumber("1e-2")).toEqual(0.01);
         expect(toNumber("1e+2")).toEqual(100);
         expect(toNumber("1.e+2")).toEqual(100);
     });
 
     it("scientific notation with upper E", () => {
-        expect(toNumber("01.0E2"  ,  { leadingZeros :  false})).toEqual("01.0E2");
-        expect(toNumber("-01.0E2"  ,  { leadingZeros :  false})).toEqual("-01.0E2");
-        expect(toNumber("01.0E2") ).toEqual(100);
-        expect(toNumber("-01.0E2") ).toEqual(-100);
-        expect(toNumber("1.0E2") ).toEqual(100);
+        expect(toNumber("01.0E2", { leadingZeros: false })).toEqual("01.0E2");
+        expect(toNumber("-01.0E2", { leadingZeros: false })).toEqual("-01.0E2");
+        expect(toNumber("01.0E2")).toEqual(100);
+        expect(toNumber("-01.0E2")).toEqual(-100);
+        expect(toNumber("1.0E2")).toEqual(100);
 
-        expect(toNumber("-1.0E2") ).toEqual(-100);
+        expect(toNumber("-1.0E2")).toEqual(-100);
         expect(toNumber("1.0E-2")).toEqual(0.01);
 
         expect(toNumber("E-2")).toEqual("E-2");
@@ -144,16 +143,16 @@ describe("Should convert all the valid numeric strings to number", () => {
         expect(toNumber("0E2")).toEqual(0);
         expect(toNumber("-0E2")).toEqual(-0);
         expect(toNumber("00E2")).toEqual("00E2");
-        expect(toNumber("00E2",  { leadingZeros :  false})).toEqual("00E2");
+        expect(toNumber("00E2", { leadingZeros: false })).toEqual("00E2");
     });
-    
+
     it("should skip matching pattern", () => {
         expect(toNumber("0", { skipLike: /.*/ })).toEqual("0");
-        expect(toNumber("+12", { skipLike: /\+[0-9]{10}/} )).toEqual(12);
-        expect(toNumber("12+12", { skipLike: /\+[0-9]{10}/} )).toEqual("12+12");
-        expect(toNumber("12+1212121212", { skipLike: /\+[0-9]{10}/} )).toEqual("12+1212121212");
-        expect(toNumber("+1212121212") ).toEqual(1212121212);
-        expect(toNumber("+1212121212", { skipLike: /\+[0-9]{10}/} )).toEqual("+1212121212");
+        expect(toNumber("+12", { skipLike: /\+[0-9]{10}/ })).toEqual(12);
+        expect(toNumber("12+12", { skipLike: /\+[0-9]{10}/ })).toEqual("12+12");
+        expect(toNumber("12+1212121212", { skipLike: /\+[0-9]{10}/ })).toEqual("12+1212121212");
+        expect(toNumber("+1212121212")).toEqual(1212121212);
+        expect(toNumber("+1212121212", { skipLike: /\+[0-9]{10}/ })).toEqual("+1212121212");
     })
     it("should not change string if not number", () => {
         expect(toNumber("+12 12")).toEqual("+12 12");
@@ -162,7 +161,7 @@ describe("Should convert all the valid numeric strings to number", () => {
     it("should ignore sorrounded spaces ", () => {
         expect(toNumber("   +1212   ")).toEqual(1212);
     })
-    
+
     it("negative numbers", () => {
         expect(toNumber("+1212")).toEqual(1212);
         expect(toNumber("+12.12")).toEqual(12.12);

package/package.json

@@ -81,21 +81,21 @@
     "organization": false
   },
   "devDependencies": {
-    "@aws-sdk/client-cloudformation": "^3.972.0",
-    "@aws-sdk/client-dynamodb": "^3.972.0",
-    "@aws-sdk/client-ecr": "^3.972.0",
-    "@aws-sdk/client-ecs": "^3.972.0",
-    "@aws-sdk/client-eventbridge": "^3.972.0",
-    "@aws-sdk/client-iam": "^3.972.0",
-    "@aws-sdk/client-s3": "^3.972.0",
-    "@aws-sdk/client-secrets-manager": "^3.972.0",
-    "@aws-sdk/client-sfn": "^3.972.0",
-    "@aws-sdk/client-sns": "^3.972.0",
-    "@aws-sdk/client-textract": "^3.972.0",
-    "@aws-sdk/lib-dynamodb": "^3.972.0",
-    "@aws/durable-execution-sdk-js-testing": "^1.1.0",
+    "@aws-sdk/client-cloudformation": "^3.1010.0",
+    "@aws-sdk/client-dynamodb": "^3.1010.0",
+    "@aws-sdk/client-ecr": "^3.1010.0",
+    "@aws-sdk/client-ecs": "^3.1010.0",
+    "@aws-sdk/client-eventbridge": "^3.1010.0",
+    "@aws-sdk/client-iam": "^3.1010.0",
+    "@aws-sdk/client-s3": "^3.1010.0",
+    "@aws-sdk/client-secrets-manager": "^3.1010.0",
+    "@aws-sdk/client-sfn": "^3.1010.0",
+    "@aws-sdk/client-sns": "^3.1010.0",
+    "@aws-sdk/client-textract": "^3.1010.0",
+    "@aws-sdk/lib-dynamodb": "^3.1010.0",
+    "@aws/durable-execution-sdk-js-testing": "^1.1.1",
     "@stylistic/eslint-plugin": "^2",
-    "@types/aws-lambda": "^8.10.160",
+    "@types/aws-lambda": "^8.10.161",
     "@types/jest": "^29.5.14",
     "@types/mjml": "^4.7.4",
     "@types/node": "^18.19.130",
@@ -107,31 +107,31 @@
     "aws-sdk-client-mock": "^2.2.0",
     "aws-sdk-client-mock-jest": "^2.2.0",
     "commit-and-tag-version": "^12",
-    "constructs": "10.0.5",
-    "esbuild": "^0.27.2",
+    "constructs": "10.5.1",
+    "esbuild": "^0.27.4",
     "eslint": "^9",
     "eslint-import-resolver-typescript": "^3.10.1",
     "eslint-plugin-import": "^2.32.0",
     "jest": "^29.7.0",
     "jest-junit": "^16",
     "jsii": "5.x",
-    "jsii-diff": "^1.125.0",
+    "jsii-diff": "^1.127.0",
     "jsii-docgen": "^10.5.0",
-    "jsii-pacmak": "^1.125.0",
+    "jsii-pacmak": "^1.127.0",
     "jsii-rosetta": "5.x",
     "nock": "^13.5.6",
-    "projen": "^0.99.4",
+    "projen": "^0.99.20",
     "ts-jest": "^29.4.6",
     "ts-node": "^10.9.2",
     "typescript": "^5.9.3"
   },
   "peerDependencies": {
     "aws-cdk-lib": "^2.232.0",
-    "constructs": "^10.0.5"
+    "constructs": "^10.5.1"
   },
   "dependencies": {
-    "@aws/durable-execution-sdk-js": "^1.0.1",
-    "@slack/web-api": "^7.13.0",
+    "@aws/durable-execution-sdk-js": "^1.1.0",
+    "@slack/web-api": "^7.15.0",
     "got": "^11.8.6",
     "mjml": "^4.18.0"
   },
@@ -149,7 +149,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.12.8",
+  "version": "0.12.10",
   "jest": {
     "coverageProvider": "v8",
     "testMatch": [