@wavemaker/react-runtime 11.14.1-15.6409

package/core/proxy-service.js

@@ -0,0 +1,412 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createWidgetProxy = exports.createStateProxy = exports.createPageProxy = void 0;
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _scriptRegistry = require("@wavemaker/react-runtime/core/script-registry");
+var _dom = require("@wavemaker/react-runtime/core/util/dom");
+var _widgetObserver = require("@wavemaker/react-runtime/core/widget-observer");
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2["default"])(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+// WeakMap to store proxy flags without exposing them as props
+var proxyMap = new WeakMap();
+
+// Store the original target for each proxy
+var originalTargets = new WeakMap();
+
+// Array methods that mutate the array and should trigger updates
+var MUTATING_ARRAY_METHODS = ["push", "pop", "shift", "unshift", "splice", "sort", "reverse", "fill", "copyWithin", "put"];
+
+// Create a special proxy for arrays that preserves native behavior but triggers updates
+var createArrayProxy = function createArrayProxy(array, widgetName, propName, setPageContext) {
+  if (proxyMap.has(array)) {
+    return array;
+  }
+  var arrayProxy = new Proxy(array, {
+    get: function get(target, prop) {
+      var value = target[prop];
+
+      // If it's a mutating method, wrap it to trigger updates
+      if (typeof prop === "string" && MUTATING_ARRAY_METHODS.includes(prop) && typeof value === "function") {
+        return function () {
+          for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+            args[_key] = arguments[_key];
+          }
+          var result = value.apply(target, args);
+
+          // Trigger page context update after mutation
+          setPageContext(function (prevContext) {
+            return _objectSpread(_objectSpread({}, prevContext), {}, {
+              Widgets: _objectSpread(_objectSpread({}, prevContext.Widgets), {}, (0, _defineProperty2["default"])({}, widgetName, _objectSpread(_objectSpread({}, prevContext.Widgets[widgetName]), {}, (0, _defineProperty2["default"])({}, propName, (0, _toConsumableArray2["default"])(target)))))
+            });
+          });
+          return result;
+        };
+      }
+      return value;
+    },
+    set: function set(target, prop, value) {
+      var result = Reflect.set(target, prop, value);
+
+      // Trigger update for index assignments (arr[0] = value)
+      if (typeof prop === "string" && /^\d+$/.test(prop)) {
+        setPageContext(function (prevContext) {
+          return _objectSpread(_objectSpread({}, prevContext), {}, {
+            Widgets: _objectSpread(_objectSpread({}, prevContext.Widgets), {}, (0, _defineProperty2["default"])({}, widgetName, _objectSpread(_objectSpread({}, prevContext.Widgets[widgetName]), {}, (0, _defineProperty2["default"])({}, propName, (0, _toConsumableArray2["default"])(target)))))
+          });
+        });
+      }
+      return result;
+    }
+  });
+  proxyMap.set(arrayProxy, true);
+  return arrayProxy;
+};
+
+// Create array proxy for state context
+var createStateArrayProxy = function createStateArrayProxy(array, path, propName, setPageContext) {
+  if (proxyMap.has(array)) {
+    return array;
+  }
+  var arrayProxy = new Proxy(array, {
+    get: function get(target, prop) {
+      var value = target[prop];
+
+      // If it's a mutating method, wrap it to trigger updates
+      if (typeof prop === "string" && MUTATING_ARRAY_METHODS.includes(prop) && typeof value === "function") {
+        return function () {
+          for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+            args[_key2] = arguments[_key2];
+          }
+          var result = value.apply(target, args);
+
+          // Trigger state context update after mutation
+          setPageContext(function (prev) {
+            var newState = _objectSpread({}, prev);
+            var current = newState;
+            for (var i = 0; i < path.length; i++) {
+              var key = path[i];
+              current[key] = _objectSpread({}, current[key]);
+              current = current[key];
+            }
+
+            // Set the new array reference to trigger re-render
+            current[propName] = (0, _toConsumableArray2["default"])(target);
+            return newState;
+          });
+          return result;
+        };
+      }
+      return value;
+    },
+    set: function set(target, prop, value) {
+      var result = Reflect.set(target, prop, value);
+
+      // Trigger update for index assignments (arr[0] = value)
+      if (typeof prop === "string" && /^\d+$/.test(prop)) {
+        setPageContext(function (prev) {
+          var newState = _objectSpread({}, prev);
+          var current = newState;
+          for (var i = 0; i < path.length; i++) {
+            var key = path[i];
+            current[key] = _objectSpread({}, current[key]);
+            current = current[key];
+          }
+
+          // Set the new array reference to trigger re-render
+          current[propName] = (0, _toConsumableArray2["default"])(target);
+          return newState;
+        });
+      }
+      return result;
+    }
+  });
+  proxyMap.set(arrayProxy, true);
+  return arrayProxy;
+};
+var createWidgetProxy = exports.createWidgetProxy = function createWidgetProxy(widget, widgetName, setPageContext) {
+  // If widget is already a proxy or is a DOM element, return it directly
+  if (proxyMap.has(widget) || (0, _dom.isDOMElement)(widget)) {
+    return widget;
+  }
+  var proxy = new Proxy(widget, {
+    set: function set(target, prop, value) {
+      // Ignore internal properties
+      if ((0, _typeof2["default"])(prop) === "symbol" || prop === "prototype") {
+        return true;
+      }
+
+      // Skip if value hasn't changed
+      if (target[prop] === value) {
+        return true;
+      }
+
+      // track script-modified properties
+      if (typeof prop === "string") {
+        var widgetId = widget["data-widget-id"];
+        (0, _scriptRegistry.trackOverriddenProps)(widgetName, prop, value, widgetId);
+      }
+      target[prop] = value;
+      setPageContext(function (prevContext) {
+        // Check if widget-id matches before updating context
+        var currentWidget = prevContext.Widgets[widgetName];
+        var registryWidgetId = currentWidget === null || currentWidget === void 0 ? void 0 : currentWidget["data-widget-id"];
+        var widgetId = widget["data-widget-id"];
+        if (currentWidget && registryWidgetId && widgetId) {
+          // Only update if widget-id matches
+          if (registryWidgetId === widgetId) {
+            return _objectSpread(_objectSpread({}, prevContext), {}, {
+              Widgets: _objectSpread(_objectSpread({}, prevContext.Widgets), {}, (0, _defineProperty2["default"])({}, widgetName, _objectSpread(_objectSpread({}, prevContext.Widgets[widgetName]), {}, (0, _defineProperty2["default"])({}, prop, value))))
+            });
+          }
+          // If widget-id doesn't match, don't update context
+          return prevContext;
+        }
+
+        // No widget-id present, don't update
+        return prevContext; // Don't update context if no widget-id match
+      });
+      return true;
+    },
+    get: function get(target, prop) {
+      if ((0, _typeof2["default"])(prop) === "symbol" || prop === "prototype") {
+        return undefined;
+      }
+
+      //  setProperty method to set properties dynamically
+      if (prop === "setProperty") {
+        return function (key, value) {
+          proxy[key] = value;
+          return this;
+        };
+      }
+
+      // Special getter for $element - return jQuery-like wrapped element
+      if (prop === "$element") {
+        var rawElement = target[prop];
+        if (rawElement) {
+          // If already wrapped, return as-is
+          if (rawElement.length === 1 && (0, _dom.isDOMElement)(rawElement[0])) {
+            return rawElement;
+          }
+          // If raw DOM element, wrap it
+          if ((0, _dom.isDOMElement)(rawElement)) {
+            return (0, _dom.wrapWithNativeDOM)(rawElement);
+          }
+        }
+
+        // Try to find element in DOM directly
+        var widgetId = widget["data-widget-id"];
+        var element = (0, _widgetObserver.findWidgetElement)(widgetName, widgetId);
+        if (element) {
+          var wrappedElement = (0, _dom.wrapWithNativeDOM)(element);
+          target[prop] = wrappedElement; // Cache the wrapped element
+          return wrappedElement;
+        }
+
+        // Register for future element updates if not found
+        if (!target._elementCallbackRegistered) {
+          var key = widgetId ? "".concat(widgetName, ":").concat(widgetId) : widgetName;
+          var callbacks = _widgetObserver.widgetElementCallbacks.get(key);
+          if (!callbacks) {
+            callbacks = new Set();
+            _widgetObserver.widgetElementCallbacks.set(key, callbacks);
+          }
+          callbacks.add(function (element) {
+            if (element) {
+              target[prop] = (0, _dom.wrapWithNativeDOM)(element);
+            }
+          });
+          target._elementCallbackRegistered = true;
+        }
+        return null;
+      }
+      var value = target[prop];
+
+      // Return DOM elements directly to preserve their context
+      if ((0, _dom.isDOMElement)(value)) {
+        return value;
+      }
+
+      // Return array proxy to preserve native array behavior while enabling reactivity
+      if (Array.isArray(value) && typeof prop === "string") {
+        return createArrayProxy(value, widgetName, prop, setPageContext);
+      }
+      return value;
+    }
+  });
+
+  // Store proxy flag in WeakMap
+  proxyMap.set(proxy, true);
+  // Store original target reference
+  originalTargets.set(proxy, widget);
+  return proxy;
+};
+var createPageProxy = exports.createPageProxy = function createPageProxy(target, setPageContext) {
+  // Cache for widget proxies
+  var widgetProxies = new Map();
+  return new Proxy(target, {
+    get: function get(widgetsTarget, widgetName) {
+      // Handle non-string properties
+      if (widgetName === undefined || widgetName === "undefined") {
+        return undefined;
+      }
+      if (typeof widgetName !== "string") {
+        return widgetsTarget[widgetName];
+      }
+
+      // Initialize widget if it doesn't exist
+      if (!(widgetName in widgetsTarget)) {
+        widgetsTarget[widgetName] = {
+          name: widgetName
+        };
+      }
+      var widget = widgetsTarget[widgetName];
+
+      // Return cached proxy if available
+      if (widgetProxies.has(widgetName)) {
+        var _proxy = widgetProxies.get(widgetName);
+        var originalTarget = originalTargets.get(_proxy);
+
+        // Always sync properties to ensure proxy has latest data
+        // This is important when widget was initially created with minimal data
+        if (widget !== originalTarget || Object.keys(widget).length > Object.keys(originalTarget).length) {
+          // Copy all properties from widget to originalTarget
+          for (var key in widget) {
+            originalTarget[key] = widget[key];
+          }
+        }
+        return _proxy;
+      }
+
+      // Create and cache a new proxy
+      var proxy = createWidgetProxy(widget, widgetName, setPageContext);
+      widgetProxies.set(widgetName, proxy);
+      return proxy;
+    },
+    set: function set(widgetsTarget, widgetName, widgetValue) {
+      // Skip if nothing changed
+      if (widgetsTarget[widgetName] === widgetValue) {
+        return true;
+      }
+
+      // Update the widget in the target
+      widgetsTarget[widgetName] = widgetValue;
+
+      // Update existing proxy or create a new one
+      if (widgetProxies.has(widgetName)) {
+        var proxy = widgetProxies.get(widgetName);
+        var originalTarget = originalTargets.get(proxy);
+
+        // Only copy changed properties
+        for (var key in widgetValue) {
+          if (originalTarget[key] !== widgetValue[key]) {
+            originalTarget[key] = widgetValue[key];
+          }
+        }
+      } else if (widgetValue && (0, _typeof2["default"])(widgetValue) === "object") {
+        // Create a new proxy
+        var _proxy2 = createWidgetProxy(widgetValue, widgetName, setPageContext);
+        widgetProxies.set(widgetName, _proxy2);
+      }
+      setPageContext(function (prev) {
+        return _objectSpread(_objectSpread({}, prev), {}, {
+          Widgets: widgetsTarget
+        });
+      });
+      return true;
+    }
+  });
+};
+var createStateProxy = exports.createStateProxy = function createStateProxy(obj) {
+  var path = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  var setPageContext = arguments.length > 2 ? arguments[2] : undefined;
+  // Cache for nested proxies
+  var nestedProxies = new Map();
+  return new Proxy(obj, {
+    get: function get(target, prop) {
+      if (prop === "eval") {
+        return function (fn) {
+          var failOnError = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+          try {
+            return fn.call(target);
+          } catch (e) {
+            if (failOnError) throw e;
+            return null;
+          }
+        };
+      }
+      if (prop === "Widgets" && path.length === 0) {
+        if (!nestedProxies.has("Widgets")) {
+          nestedProxies.set("Widgets", createPageProxy(target.Widgets, setPageContext));
+        }
+        return nestedProxies.get("Widgets");
+      }
+
+      // Do not auto-create missing properties; just return undefined
+      if (!(prop in target)) {
+        return undefined;
+      }
+      var value = target[prop];
+
+      // Return primitives directly
+      if ((0, _typeof2["default"])(value) !== "object" || value === null) {
+        return value;
+      }
+
+      // Return DOM elements directly without proxying
+      if ((0, _dom.isDOMElement)(value)) {
+        return value;
+      }
+
+      // Return array proxy to preserve native array behavior while enabling reactivity
+      if (Array.isArray(value)) {
+        return createStateArrayProxy(value, path, prop, setPageContext);
+      }
+
+      // Use cached proxy if available
+      if (nestedProxies.has(prop)) {
+        return nestedProxies.get(prop);
+      }
+
+      // Create and cache a new nested proxy
+      var nestedProxy = createStateProxy(value, [].concat((0, _toConsumableArray2["default"])(path), [prop]), setPageContext);
+      nestedProxies.set(prop, nestedProxy);
+      return nestedProxy;
+    },
+    set: function set(target, prop, value) {
+      // Skip if value hasn't changed
+      if (target[prop] === value) {
+        return true;
+      }
+
+      // Update target directly
+      target[prop] = value;
+
+      // Clear cached proxy if value is an object (but not an array)
+      if ((0, _typeof2["default"])(value) === "object" && value !== null && !Array.isArray(value) && nestedProxies.has(prop)) {
+        nestedProxies["delete"](prop);
+      }
+      setPageContext(function (prev) {
+        // Create minimal copies along path
+        var newState = _objectSpread({}, prev);
+        var current = newState;
+        for (var i = 0; i < path.length; i++) {
+          var key = path[i];
+          current[key] = _objectSpread({}, current[key]);
+          current = current[key];
+        }
+
+        // Set the value
+        current[prop] = value;
+        return newState;
+      });
+      return true;
+    }
+  });
+};

package/core/script-registry.js

@@ -0,0 +1,63 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.clearOverriddenProps = clearOverriddenProps;
+exports.getWidgetOverrides = getWidgetOverrides;
+exports.isPropOverridden = isPropOverridden;
+exports.isWidgetOverridden = isWidgetOverridden;
+exports.overriddenProps = void 0;
+exports.trackOverriddenProps = trackOverriddenProps;
+exports.widgetIdOverriddenProps = void 0;
+// Global registry to track overridden properties
+var overriddenProps = exports.overriddenProps = {};
+
+// New: Widget-ID specific overrides
+var widgetIdOverriddenProps = exports.widgetIdOverriddenProps = {};
+var IGNORED_PROPERTIES = ["name", "activePane", "activePaneIndex", "activeTab"];
+
+// Add a property to the registry
+function trackOverriddenProps(widgetName, propName, value, widgetId) {
+  if (IGNORED_PROPERTIES.includes(propName)) return;
+
+  // If widget-id is provided, use widget-id specific tracking
+  if (widgetId) {
+    if (!widgetIdOverriddenProps[widgetName]) {
+      widgetIdOverriddenProps[widgetName] = {};
+    }
+    if (!widgetIdOverriddenProps[widgetName][widgetId]) {
+      widgetIdOverriddenProps[widgetName][widgetId] = {};
+    }
+    widgetIdOverriddenProps[widgetName][widgetId][propName] = value;
+  } else {
+    // Fallback to global registry for backward compatibility
+    if (!overriddenProps[widgetName]) {
+      overriddenProps[widgetName] = {};
+    }
+    overriddenProps[widgetName][propName] = value;
+  }
+}
+
+// Check if a property has been script-modified
+function isPropOverridden(widgetName, propName, widgetId) {
+  var _widgetIdOverriddenPr, _overriddenProps$widg, _overriddenProps$widg2;
+  var overriddenItem = ((_widgetIdOverriddenPr = widgetIdOverriddenProps[widgetName]) === null || _widgetIdOverriddenPr === void 0 || (_widgetIdOverriddenPr = _widgetIdOverriddenPr[widgetId]) === null || _widgetIdOverriddenPr === void 0 ? void 0 : _widgetIdOverriddenPr[propName]) || (((_overriddenProps$widg = overriddenProps[widgetName]) === null || _overriddenProps$widg === void 0 ? void 0 : _overriddenProps$widg[propName]) != undefined ? (_overriddenProps$widg2 = overriddenProps[widgetName]) === null || _overriddenProps$widg2 === void 0 ? void 0 : _overriddenProps$widg2[propName] : false);
+  return overriddenItem !== undefined;
+}
+function isWidgetOverridden(widgetName, widgetId) {
+  var _widgetIdOverriddenPr2;
+  var overriddenItem = ((_widgetIdOverriddenPr2 = widgetIdOverriddenProps[widgetName]) === null || _widgetIdOverriddenPr2 === void 0 ? void 0 : _widgetIdOverriddenPr2[widgetId]) || overriddenProps[widgetName];
+  return overriddenItem !== undefined;
+}
+
+// Get widget-id specific overrides
+function getWidgetOverrides(widgetName, widgetId) {
+  var _widgetIdOverriddenPr3;
+  var overriddenItem = ((_widgetIdOverriddenPr3 = widgetIdOverriddenProps[widgetName]) === null || _widgetIdOverriddenPr3 === void 0 ? void 0 : _widgetIdOverriddenPr3[widgetId]) || overriddenProps[widgetName];
+  return overriddenItem || {};
+}
+function clearOverriddenProps() {
+  exports.overriddenProps = overriddenProps = {};
+  exports.widgetIdOverriddenProps = widgetIdOverriddenProps = {};
+}

package/core/security.service.js

@@ -0,0 +1,11 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SecurityProvider = exports.SecurityConsumer = void 0;
+var _react = _interopRequireDefault(require("react"));
+var SecurityContext = /*#__PURE__*/_react["default"].createContext(null);
+var SecurityProvider = exports.SecurityProvider = SecurityContext.Provider;
+var SecurityConsumer = exports.SecurityConsumer = SecurityContext.Consumer;

package/core/util/common.js

@@ -0,0 +1,33 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.deepCopy = void 0;
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _lodashEs = require("lodash-es");
+var _deepCopy = function _deepCopy(o1) {
+  for (var _len = arguments.length, o2 = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    o2[_key - 1] = arguments[_key];
+  }
+  o2.forEach(function (o) {
+    if (o) {
+      Object.keys(o).forEach(function (k) {
+        var v = o[k];
+        if (v && !(0, _lodashEs.isString)(v) && !(0, _lodashEs.isArray)(v) && (0, _typeof2["default"])(v) === "object") {
+          o1[k] = _deepCopy(o1[k] || {}, o[k]);
+        } else {
+          o1[k] = _deepCopy(v);
+        }
+      });
+    }
+  });
+  return o1;
+};
+var deepCopy = exports.deepCopy = function deepCopy() {
+  for (var _len2 = arguments.length, objects = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+    objects[_key2] = arguments[_key2];
+  }
+  return _deepCopy.apply(void 0, [{}].concat(objects));
+};

package/core/util/dom.js

@@ -0,0 +1,107 @@
+"use strict";
+"use client";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.wrapWithNativeDOM = exports.wrapWithJQuery = exports.setCSS = exports.isDOMElement = void 0;
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var $RAF;
+var $RAFQueue = [];
+if (typeof window !== "undefined") {
+  $RAF = window.requestAnimationFrame;
+} else {
+  $RAF = function $RAF(callback) {
+    return setTimeout(callback, 0);
+  };
+}
+var invokeLater = function invokeLater(fn) {
+  if (!$RAFQueue.length) {
+    $RAF(function () {
+      $RAFQueue.forEach(function (f) {
+        return f();
+      });
+      $RAFQueue.length = 0;
+    });
+  }
+  $RAFQueue.push(fn);
+};
+var setCSS = exports.setCSS = function setCSS(node, cssName, val, sync) {
+  if (typeof window === "undefined") return;
+  // @ts-ignore
+  var task = function task() {
+    return node.style[cssName] = val;
+  };
+  sync ? task() : invokeLater(task);
+};
+
+// Helper to check if something is a DOM element
+var isDOMElement = exports.isDOMElement = function isDOMElement(obj) {
+  if (!obj || (0, _typeof2["default"])(obj) !== "object") return false;
+
+  // Check for DOM node characteristics
+  if (typeof window !== "undefined") {
+    return obj instanceof Element || obj instanceof Node || obj.nodeType && typeof obj.nodeName === "string";
+  }
+  return false;
+};
+
+// Create empty wrapper for when elements are not found (like empty jQuery object)
+var createEmptyWrapper = function createEmptyWrapper() {
+  return {
+    0: null,
+    length: 0,
+    // Empty wrapper methods that do nothing (jQuery-like behavior)
+    find: function find() {
+      return createEmptyWrapper();
+    },
+    attr: function attr() {
+      return createEmptyWrapper();
+    },
+    removeAttr: function removeAttr() {
+      return createEmptyWrapper();
+    },
+    get: function get() {
+      return null;
+    }
+  };
+};
+
+// Minimal wrapper with essential jQuery methods that are actually used
+var wrapWithNativeDOM = exports.wrapWithNativeDOM = function wrapWithNativeDOM(element) {
+  if (!element || !isDOMElement(element)) {
+    return createEmptyWrapper();
+  }
+
+  // Create wrapper object with essential jQuery methods
+  var wrapper = {
+    // Array-like properties for jQuery compatibility
+    0: element,
+    length: 1,
+    // Essential jQuery methods using native DOM
+    find: function find(selector) {
+      var found = element.querySelector(selector);
+      return found ? wrapWithNativeDOM(found) : createEmptyWrapper();
+    },
+    attr: function attr(name, value) {
+      if (value === undefined) {
+        return element.getAttribute(name);
+      }
+      element.setAttribute(name, value);
+      return wrapper;
+    },
+    removeAttr: function removeAttr(name) {
+      element.removeAttribute(name);
+      return wrapper;
+    },
+    // Direct access to native element
+    get: function get() {
+      return element;
+    }
+  };
+  return wrapper;
+};
+
+// Backward compatibility alias
+var wrapWithJQuery = exports.wrapWithJQuery = wrapWithNativeDOM;