cdk-common 2.0.1396 → 2.0.1398

package/node_modules/qs/test/utils.js

@@ -69,12 +69,14 @@ test('merge()', function (t) {
     );
 
     t.test('with overflow objects (from arrayLimit)', function (st) {
+        // arrayLimit is max index, so with limit 0, max index 0 is allowed (1 element)
+        // To create overflow, need 2+ elements with limit 0, or 3+ with limit 1, etc.
         st.test('merges primitive into overflow object at next index', function (s2t) {
-            // Create an overflow object via combine
-            var overflow = utils.combine(['a'], 'b', 1, false);
+            // Create an overflow object via combine: 3 elements (indices 0-2) with limit 0
+            var overflow = utils.combine(['a', 'b'], 'c', 0, false);
             s2t.ok(utils.isOverflow(overflow), 'overflow object is marked');
-            var merged = utils.merge(overflow, 'c');
-            s2t.deepEqual(merged, { 0: 'a', 1: 'b', 2: 'c' }, 'adds primitive at next numeric index');
+            var merged = utils.merge(overflow, 'd');
+            s2t.deepEqual(merged, { 0: 'a', 1: 'b', 2: 'c', 3: 'd' }, 'adds primitive at next numeric index');
             s2t.end();
         });
 
@@ -94,21 +96,21 @@ test('merge()', function (t) {
         });
 
         st.test('merges overflow object into primitive', function (s2t) {
-            // Create an overflow object via combine
-            var overflow = utils.combine([], 'b', 0, false);
+            // Create an overflow object via combine: 2 elements (indices 0-1) with limit 0
+            var overflow = utils.combine(['a'], 'b', 0, false);
             s2t.ok(utils.isOverflow(overflow), 'overflow object is marked');
-            var merged = utils.merge('a', overflow);
+            var merged = utils.merge('c', overflow);
             s2t.ok(utils.isOverflow(merged), 'result is also marked as overflow');
-            s2t.deepEqual(merged, { 0: 'a', 1: 'b' }, 'creates object with primitive at 0, source values shifted');
+            s2t.deepEqual(merged, { 0: 'c', 1: 'a', 2: 'b' }, 'creates object with primitive at 0, source values shifted');
             s2t.end();
         });
 
         st.test('merges overflow object with multiple values into primitive', function (s2t) {
-            // Create an overflow object via combine
-            var overflow = utils.combine(['b'], 'c', 1, false);
+            // Create an overflow object via combine: 3 elements (indices 0-2) with limit 0
+            var overflow = utils.combine(['b', 'c'], 'd', 0, false);
             s2t.ok(utils.isOverflow(overflow), 'overflow object is marked');
             var merged = utils.merge('a', overflow);
-            s2t.deepEqual(merged, { 0: 'a', 1: 'b', 2: 'c' }, 'shifts all source indices by 1');
+            s2t.deepEqual(merged, { 0: 'a', 1: 'b', 2: 'c', 3: 'd' }, 'shifts all source indices by 1');
             s2t.end();
         });
 
@@ -196,7 +198,7 @@ test('combine()', function (t) {
 
         st.test('exactly at the limit stays as array', function (s2t) {
             var combined = utils.combine(['a', 'b'], 'c', 3, false);
-            s2t.deepEqual(combined, ['a', 'b', 'c'], 'stays as array when exactly at limit');
+            s2t.deepEqual(combined, ['a', 'b', 'c'], 'stays as array when count equals limit');
             s2t.ok(Array.isArray(combined), 'result is an array');
             s2t.end();
         });
@@ -208,16 +210,30 @@ test('combine()', function (t) {
             s2t.end();
         });
 
-        st.test('with arrayLimit 0', function (s2t) {
+        st.test('with arrayLimit 1', function (s2t) {
+            var combined = utils.combine([], 'a', 1, false);
+            s2t.deepEqual(combined, ['a'], 'stays as array when count equals limit');
+            s2t.ok(Array.isArray(combined), 'result is an array');
+            s2t.end();
+        });
+
+        st.test('with arrayLimit 0 converts single element to object', function (s2t) {
             var combined = utils.combine([], 'a', 0, false);
-            s2t.deepEqual(combined, { 0: 'a' }, 'converts single element to object with arrayLimit 0');
+            s2t.deepEqual(combined, { 0: 'a' }, 'converts to object when count exceeds limit');
+            s2t.notOk(Array.isArray(combined), 'result is not an array');
+            s2t.end();
+        });
+
+        st.test('with arrayLimit 0 and two elements converts to object', function (s2t) {
+            var combined = utils.combine(['a'], 'b', 0, false);
+            s2t.deepEqual(combined, { 0: 'a', 1: 'b' }, 'converts to object when count exceeds limit');
             s2t.notOk(Array.isArray(combined), 'result is not an array');
             s2t.end();
         });
 
         st.test('with plainObjects option', function (s2t) {
-            var combined = utils.combine(['a'], 'b', 1, true);
-            var expected = { __proto__: null, 0: 'a', 1: 'b' };
+            var combined = utils.combine(['a', 'b'], 'c', 1, true);
+            var expected = { __proto__: null, 0: 'a', 1: 'b', 2: 'c' };
             s2t.deepEqual(combined, expected, 'converts to object with null prototype');
             s2t.equal(Object.getPrototypeOf(combined), null, 'result has null prototype when plainObjects is true');
             s2t.end();
@@ -228,13 +244,13 @@ test('combine()', function (t) {
 
     t.test('with existing overflow object', function (st) {
         st.test('adds to existing overflow object at next index', function (s2t) {
-            // Create overflow object first via combine
-            var overflow = utils.combine(['a'], 'b', 1, false);
+            // Create overflow object first via combine: 3 elements (indices 0-2) with limit 0
+            var overflow = utils.combine(['a', 'b'], 'c', 0, false);
             s2t.ok(utils.isOverflow(overflow), 'initial object is marked as overflow');
 
-            var combined = utils.combine(overflow, 'c', 10, false);
+            var combined = utils.combine(overflow, 'd', 10, false);
             s2t.equal(combined, overflow, 'returns the same object (mutated)');
-            s2t.deepEqual(combined, { 0: 'a', 1: 'b', 2: 'c' }, 'adds value at next numeric index');
+            s2t.deepEqual(combined, { 0: 'a', 1: 'b', 2: 'c', 3: 'd' }, 'adds value at next numeric index');
             s2t.end();
         });
 

package/package.json

@@ -54,7 +54,7 @@
     "jsii-docgen": "^10.5.0",
     "jsii-pacmak": "^1.126.0",
     "jsii-rosetta": "5.7.x",
-    "projen": "0.99.11",
+    "projen": "0.99.12",
     "ts-jest": "^27",
     "typescript": "^5"
   },
@@ -87,7 +87,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "2.0.1396",
+  "version": "2.0.1398",
   "jest": {
     "coverageProvider": "v8",
     "testMatch": [