@membranehq/sdk 0.11.0 → 0.11.1

package/dist/bundle.js

@@ -4954,10 +4954,32 @@
 		hasRequiredUtils = 1;
 
 		var formats = /*@__PURE__*/ requireFormats();
+		var getSideChannel = requireSideChannel();
 
 		var has = Object.prototype.hasOwnProperty;
 		var isArray = Array.isArray;
 
+		// Track objects created from arrayLimit overflow using side-channel
+		// Stores the current max numeric index for O(1) lookup
+		var overflowChannel = getSideChannel();
+
+		var markOverflow = function markOverflow(obj, maxIndex) {
+		    overflowChannel.set(obj, maxIndex);
+		    return obj;
+		};
+
+		var isOverflow = function isOverflow(obj) {
+		    return overflowChannel.has(obj);
+		};
+
+		var getMaxIndex = function getMaxIndex(obj) {
+		    return overflowChannel.get(obj);
+		};
+
+		var setMaxIndex = function setMaxIndex(obj, maxIndex) {
+		    overflowChannel.set(obj, maxIndex);
+		};
+
 		var hexTable = (function () {
 		    var array = [];
 		    for (var i = 0; i < 256; ++i) {
@@ -5007,7 +5029,12 @@
 		        if (isArray(target)) {
 		            target.push(source);
 		        } else if (target && typeof target === 'object') {
-		            if (
+		            if (isOverflow(target)) {
+		                // Add at next numeric index for overflow objects
+		                var newIndex = getMaxIndex(target) + 1;
+		                target[newIndex] = source;
+		                setMaxIndex(target, newIndex);
+		            } else if (
 		                (options && (options.plainObjects || options.allowPrototypes))
 		                || !has.call(Object.prototype, source)
 		            ) {
@@ -5021,6 +5048,18 @@
 		    }
 
 		    if (!target || typeof target !== 'object') {
+		        if (isOverflow(source)) {
+		            // Create new object with target at 0, source values shifted by 1
+		            var sourceKeys = Object.keys(source);
+		            var result = options && options.plainObjects
+		                ? { __proto__: null, 0: target }
+		                : { 0: target };
+		            for (var m = 0; m < sourceKeys.length; m++) {
+		                var oldKey = parseInt(sourceKeys[m], 10);
+		                result[oldKey + 1] = source[sourceKeys[m]];
+		            }
+		            return markOverflow(result, getMaxIndex(source) + 1);
+		        }
 		        return [target].concat(source);
 		    }
 
@@ -5192,8 +5231,20 @@
 		    return !!(obj.constructor && obj.constructor.isBuffer && obj.constructor.isBuffer(obj));
 		};
 
-		var combine = function combine(a, b) {
-		    return [].concat(a, b);
+		var combine = function combine(a, b, arrayLimit, plainObjects) {
+		    // If 'a' is already an overflow object, add to it
+		    if (isOverflow(a)) {
+		        var newIndex = getMaxIndex(a) + 1;
+		        a[newIndex] = b;
+		        setMaxIndex(a, newIndex);
+		        return a;
+		    }
+
+		    var result = [].concat(a, b);
+		    if (result.length > arrayLimit) {
+		        return markOverflow(arrayToObject(result, { plainObjects: plainObjects }), result.length - 1);
+		    }
+		    return result;
 		};
 
 		var maybeMap = function maybeMap(val, fn) {
@@ -5215,6 +5266,7 @@
 		    decode: decode,
 		    encode: encode,
 		    isBuffer: isBuffer,
+		    isOverflow: isOverflow,
 		    isRegExp: isRegExp,
 		    maybeMap: maybeMap,
 		    merge: merge
@@ -5701,16 +5753,18 @@
 		        } else {
 		            key = options.decoder(part.slice(0, pos), defaults.decoder, charset, 'key');
 
-		            val = utils.maybeMap(
-		                parseArrayValue(
-		                    part.slice(pos + 1),
-		                    options,
-		                    isArray(obj[key]) ? obj[key].length : 0
-		                ),
-		                function (encodedVal) {
-		                    return options.decoder(encodedVal, defaults.decoder, charset, 'value');
-		                }
-		            );
+		            if (key !== null) {
+		                val = utils.maybeMap(
+		                    parseArrayValue(
+		                        part.slice(pos + 1),
+		                        options,
+		                        isArray(obj[key]) ? obj[key].length : 0
+		                    ),
+		                    function (encodedVal) {
+		                        return options.decoder(encodedVal, defaults.decoder, charset, 'value');
+		                    }
+		                );
+		            }
 		        }
 
 		        if (val && options.interpretNumericEntities && charset === 'iso-8859-1') {
@@ -5721,11 +5775,18 @@
 		            val = isArray(val) ? [val] : val;
 		        }
 
-		        var existing = has.call(obj, key);
-		        if (existing && options.duplicates === 'combine') {
-		            obj[key] = utils.combine(obj[key], val);
-		        } else if (!existing || options.duplicates === 'last') {
-		            obj[key] = val;
+		        if (key !== null) {
+		            var existing = has.call(obj, key);
+		            if (existing && options.duplicates === 'combine') {
+		                obj[key] = utils.combine(
+		                    obj[key],
+		                    val,
+		                    options.arrayLimit,
+		                    options.plainObjects
+		                );
+		            } else if (!existing || options.duplicates === 'last') {
+		                obj[key] = val;
+		            }
 		        }
 		    }
 
@@ -5746,9 +5807,19 @@
 		        var root = chain[i];
 
 		        if (root === '[]' && options.parseArrays) {
-		            obj = options.allowEmptyArrays && (leaf === '' || (options.strictNullHandling && leaf === null))
-		                ? []
-		                : utils.combine([], leaf);
+		            if (utils.isOverflow(leaf)) {
+		                // leaf is already an overflow object, preserve it
+		                obj = leaf;
+		            } else {
+		                obj = options.allowEmptyArrays && (leaf === '' || (options.strictNullHandling && leaf === null))
+		                    ? []
+		                    : utils.combine(
+		                        [],
+		                        leaf,
+		                        options.arrayLimit,
+		                        options.plainObjects
+		                    );
+		            }
 		        } else {
 		            obj = options.plainObjects ? { __proto__: null } : {};
 		            var cleanRoot = root.charAt(0) === '[' && root.charAt(root.length - 1) === ']' ? root.slice(1, -1) : root;
@@ -5776,29 +5847,28 @@
 		    return leaf;
 		};
 
-		var parseKeys = function parseQueryStringKeys(givenKey, val, options, valuesParsed) {
-		    if (!givenKey) {
-		        return;
-		    }
-
-		    // Transform dot notation to bracket notation
+		var splitKeyIntoSegments = function splitKeyIntoSegments(givenKey, options) {
 		    var key = options.allowDots ? givenKey.replace(/\.([^.[]+)/g, '[$1]') : givenKey;
 
-		    // The regex chunks
+		    if (options.depth <= 0) {
+		        if (!options.plainObjects && has.call(Object.prototype, key)) {
+		            if (!options.allowPrototypes) {
+		                return;
+		            }
+		        }
+
+		        return [key];
+		    }
 
 		    var brackets = /(\[[^[\]]*])/;
 		    var child = /(\[[^[\]]*])/g;
 
-		    // Get the parent
-
-		    var segment = options.depth > 0 && brackets.exec(key);
+		    var segment = brackets.exec(key);
 		    var parent = segment ? key.slice(0, segment.index) : key;
 
-		    // Stash the parent if it exists
-
 		    var keys = [];
+
 		    if (parent) {
-		        // If we aren't using plain objects, optionally prefix keys that would overwrite object prototype properties
 		        if (!options.plainObjects && has.call(Object.prototype, parent)) {
 		            if (!options.allowPrototypes) {
 		                return;
@@ -5808,28 +5878,42 @@
 		        keys.push(parent);
 		    }
 
-		    // Loop through children appending to the array until we hit depth
-
 		    var i = 0;
-		    while (options.depth > 0 && (segment = child.exec(key)) !== null && i < options.depth) {
+		    while ((segment = child.exec(key)) !== null && i < options.depth) {
 		        i += 1;
-		        if (!options.plainObjects && has.call(Object.prototype, segment[1].slice(1, -1))) {
+
+		        var segmentContent = segment[1].slice(1, -1);
+		        if (!options.plainObjects && has.call(Object.prototype, segmentContent)) {
 		            if (!options.allowPrototypes) {
 		                return;
 		            }
 		        }
+
 		        keys.push(segment[1]);
 		    }
 
-		    // If there's a remainder, check strictDepth option for throw, else just add whatever is left
-
 		    if (segment) {
 		        if (options.strictDepth === true) {
 		            throw new RangeError('Input depth exceeded depth option of ' + options.depth + ' and strictDepth is true');
 		        }
+
 		        keys.push('[' + key.slice(segment.index) + ']');
 		    }
 
+		    return keys;
+		};
+
+		var parseKeys = function parseQueryStringKeys(givenKey, val, options, valuesParsed) {
+		    if (!givenKey) {
+		        return;
+		    }
+
+		    var keys = splitKeyIntoSegments(givenKey, options);
+
+		    if (!keys) {
+		        return;
+		    }
+
 		    return parseObject(keys, val, options, valuesParsed);
 		};
 
@@ -20090,6 +20174,7 @@
 	    parentUuid: string$1().optional(),
 	    connectionId: string$1().optional(),
 	    instanceKey: string$1().optional(),
+	    isUniversal: boolean$1().optional(),
 	});
 	const BaseIntegrationLevelMembraneInterfaceReadOnlyProperties = BaseMembraneInterfaceReadOnlyProperties.extend({
 	    isCustomized: boolean$1().optional(),
@@ -20101,16 +20186,60 @@
 	});
 	const MembraneElementLayer = _enum(['universal', 'integration', 'connection']);
 	const IntegrationLevelMembraneInterfaceSelectorQuery = object({
-	    layer: MembraneElementLayer.optional(),
-	    integrationKey: string$1().optional(),
-	    integrationId: string$1().optional(),
-	    connectionId: string$1().optional(),
-	    instanceKey: string$1().optional(),
+	    layer: MembraneElementLayer.optional().meta({
+	        filterTitle: 'Layer',
+	    }),
+	    integrationKey: string$1()
+	        .optional()
+	        .meta({
+	        hidden: true,
+	    }),
+	    integrationId: string$1()
+	        .optional()
+	        .meta({
+	        filterTitle: 'Integration',
+	        referenceElementType: WorkspaceElementType.Integration,
+	    }),
+	    connectionId: string$1()
+	        .optional()
+	        .meta({
+	        filterTitle: 'Connection',
+	        referenceElementType: WorkspaceElementType.Connection,
+	    }),
+	    instanceKey: string$1()
+	        .optional()
+	        .meta({
+	        filterTitle: 'Instance Key',
+	    }),
 	});
 	IntegrationLevelMembraneInterfaceSelectorQuery.extend(CommonListElementsQuery.shape).extend({
-	    parentId: string$1().optional(),
-	    universalParentId: string$1().optional(),
-	    userId: string$1().optional(),
+	    parentId: string$1()
+	        .optional()
+	        .meta({
+	        filterTitle: 'Parent',
+	        referenceElementType: 'self',
+	    }),
+	    universalParentId: string$1()
+	        .optional()
+	        .meta({
+	        filterTitle: 'Universal Parent',
+	        referenceElementType: 'self',
+	    }),
+	    tenantId: string$1()
+	        .optional()
+	        .meta({
+	        filterTitle: 'Customer',
+	        referenceElementType: WorkspaceElementType.Customer,
+	    }),
+	    userId: string$1().optional().meta({
+	        hidden: true,
+	    }),
+	    isUniversal: zodBooleanCoercion()
+	        .optional()
+	        .meta({
+	        filterTitle: 'Is Universal',
+	        isFlag: true,
+	    }),
 	});
 	BaseMembraneInterface.merge(BaseIntegrationLevelMembraneInterfaceEditableProperties).merge(BaseIntegrationLevelMembraneInterfaceReadOnlyProperties);
 	object({