@dereekb/dbx-web 13.21.0 → 13.22.0

package/eslint/index.cjs.js

@@ -1428,7 +1428,7 @@
     return result;
 }
 
-function _array_like_to_array(arr, len) {
+function _array_like_to_array$1(arr, len) {
     if (len == null || len > arr.length) len = arr.length;
     for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
     return arr2;
@@ -1436,10 +1436,10 @@ function _array_like_to_array(arr, len) {
 function _array_with_holes(arr) {
     if (Array.isArray(arr)) return arr;
 }
-function _array_without_holes(arr) {
-    if (Array.isArray(arr)) return _array_like_to_array(arr);
+function _array_without_holes$1(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array$1(arr);
 }
-function _iterable_to_array(iter) {
+function _iterable_to_array$1(iter) {
     if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
 }
 function _iterable_to_array_limit(arr, i) {
@@ -1469,26 +1469,26 @@ function _iterable_to_array_limit(arr, i) {
 function _non_iterable_rest() {
     throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 }
-function _non_iterable_spread() {
+function _non_iterable_spread$1() {
     throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 }
 function _sliced_to_array(arr, i) {
-    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array$1(arr, i) || _non_iterable_rest();
 }
-function _to_consumable_array(arr) {
-    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+function _to_consumable_array$1(arr) {
+    return _array_without_holes$1(arr) || _iterable_to_array$1(arr) || _unsupported_iterable_to_array$1(arr) || _non_iterable_spread$1();
 }
-function _type_of(obj) {
+function _type_of$1(obj) {
     "@swc/helpers - typeof";
     return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
 }
-function _unsupported_iterable_to_array(o, minLen) {
+function _unsupported_iterable_to_array$1(o, minLen) {
     if (!o) return;
-    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    if (typeof o === "string") return _array_like_to_array$1(o, minLen);
     var n = Object.prototype.toString.call(o).slice(8, -1);
     if (n === "Object" && o.constructor) n = o.constructor.name;
     if (n === "Map" || n === "Set") return Array.from(n);
-    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$1(o, minLen);
 }
 /**
  * Module that exposes the `toSignal` factory.
@@ -2038,7 +2038,7 @@ function _unsupported_iterable_to_array(o, minLen) {
                         }
                     }
                 }
-            } else if (child && (typeof child === "undefined" ? "undefined" : _type_of(child)) === 'object' && typeof child.type === 'string') {
+            } else if (child && (typeof child === "undefined" ? "undefined" : _type_of$1(child)) === 'object' && typeof child.type === 'string') {
                 walk(child, conditional, state);
             }
         }
@@ -2438,7 +2438,7 @@ function _unsupported_iterable_to_array(o, minLen) {
  * @returns The expression text with every flagged call site replaced.
  */ function substituteInExpression(plan, sourceCode) {
     var bodyStart = plan.body.range[0];
-    var ordered = _to_consumable_array(plan.replacements).sort(function(a, b) {
+    var ordered = _to_consumable_array$1(plan.replacements).sort(function(a, b) {
         return b.node.range[0] - a.node.range[0];
     });
     var result = sourceCode.getText(plan.body);
@@ -2516,6 +2516,411 @@ function _unsupported_iterable_to_array(o, minLen) {
     return preview;
 }
 
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+/**
+ * Attribute selector that marks an element as a `dbxAction` context host.
+ */ var DBX_ACTION_SELECTOR = 'dbxAction';
+/**
+ * Element selector form of the action context host (`<dbx-action>`).
+ */ var DBX_ACTION_ELEMENT_SELECTOR = 'dbx-action';
+/**
+ * Selector for the action handler input (`[dbxActionHandler]`).
+ */ var DBX_ACTION_HANDLER_SELECTOR = 'dbxActionHandler';
+/**
+ * Selector for the directive that forwards an externally-provided action store
+ * (`[dbxActionSource]`). When present, the value/store may be supplied entirely
+ * in TypeScript, so a static template scan cannot reason about completeness.
+ */ var DBX_ACTION_SOURCE_SELECTOR = 'dbxActionSource';
+/**
+ * Selectors that cause the action to enter the TRIGGERED state.
+ */ var DBX_ACTION_TRIGGER_SELECTORS = [
+    'dbxActionButton',
+    'dbxActionButtonTrigger',
+    'dbxActionKeyTrigger',
+    'dbxActionAutoTrigger'
+];
+/**
+ * Selectors that provide a value to the action (advancing TRIGGERED → VALUE_READY).
+ *
+ * Includes the bare `dbxActionValue` (which readies the empty-string sentinel on
+ * trigger) and every directive that calls `readyValue()`/`reject()` off `triggered$`.
+ */ var DBX_ACTION_VALUE_SOURCE_SELECTORS = [
+    'dbxActionValue',
+    'dbxActionValueGetter',
+    'dbxActionValueStream',
+    'dbxActionForm',
+    'dbxActionConfirm',
+    'dbxActionDialog',
+    'dbxActionPopover',
+    'dbxPdfMergeUploadAction'
+];
+/**
+ * Selectors that present/handle an action's error.
+ */ var DBX_ACTION_ERROR_DIRECTIVE_SELECTORS = [
+    'dbxActionSnackbarError',
+    'dbxActionError',
+    'dbxActionSnackbar',
+    'dbxActionErrorHandler'
+];
+/**
+ * Array-valued child-bearing properties of Angular template AST nodes that a
+ * context scan must descend into (element/template children plus the branches and
+ * cases of `@if`/`@switch` control-flow blocks).
+ */ var DBX_ACTION_CHILD_LIST_KEYS = [
+    'children',
+    'branches',
+    'cases'
+];
+/**
+ * Single-node child-bearing properties of control-flow blocks (`@for` empty,
+ * `@defer` placeholder/loading/error).
+ */ var DBX_ACTION_CHILD_NODE_KEYS = [
+    'empty',
+    'placeholder',
+    'loading',
+    'error'
+];
+/**
+ * Returns the attribute/input selector names present on a template element node.
+ *
+ * Reads plain attributes (`node.attributes`, e.g. `dbxActionButton`), bound inputs
+ * (`node.inputs`, e.g. `[dbxActionValue]` whose `.name` has no brackets), and the
+ * structural template attributes (`node.templateAttrs`).
+ *
+ * @param node - The template AST node.
+ * @returns The selector names found on the node.
+ */ function elementTokenNames(node) {
+    var _ref, _ref1, _ref2;
+    var attributes = (_ref = node === null || node === void 0 ? void 0 : node.attributes) !== null && _ref !== void 0 ? _ref : [];
+    var inputs = (_ref1 = node === null || node === void 0 ? void 0 : node.inputs) !== null && _ref1 !== void 0 ? _ref1 : [];
+    var templateAttrs = (_ref2 = node === null || node === void 0 ? void 0 : node.templateAttrs) !== null && _ref2 !== void 0 ? _ref2 : [];
+    return _to_consumable_array(attributes).concat(_to_consumable_array(inputs), _to_consumable_array(templateAttrs)).map(function(attr) {
+        return attr === null || attr === void 0 ? void 0 : attr.name;
+    }).filter(function(name) {
+        return typeof name === 'string';
+    });
+}
+/**
+ * Returns true when the node is a `dbxAction` context host — either the
+ * `<dbx-action>` element or any element carrying the `dbxAction` attribute.
+ *
+ * @param node - The template AST node.
+ * @returns True when the node hosts an action context.
+ */ function isActionHost(node) {
+    return (node === null || node === void 0 ? void 0 : node.name) === DBX_ACTION_ELEMENT_SELECTOR || elementTokenNames(node).includes(DBX_ACTION_SELECTOR);
+}
+/**
+ * Returns true when the given selector is present on the node itself or on any of
+ * its ancestors (walked via the auto-populated `.parent` chain).
+ *
+ * @param node - The starting template AST node.
+ * @param selector - The selector name to look for.
+ * @returns True when the selector is found on the node or an ancestor.
+ */ function hasTokenOnSelfOrAncestor(node, selector) {
+    var current = node;
+    var found = false;
+    while(current && !found){
+        if (elementTokenNames(current).includes(selector)) {
+            found = true;
+        } else {
+            current = current.parent;
+        }
+    }
+    return found;
+}
+/**
+ * Scans the subtree rooted at a `dbxAction` element, collecting the directive
+ * selectors present on the element and its descendants.
+ *
+ * Descent steps through structural wrappers (`Template`) and control-flow blocks
+ * (`@if`/`@for`/`@switch`/`@defer`). A nested action host re-scopes the context, so
+ * the scan flags `nestedAction` and does not descend into it (its value source
+ * belongs to the inner context, not this one).
+ *
+ * @param root - The `dbxAction` element node to scan from.
+ * @returns The collected selector tokens and whether a nested action was found.
+ */ function collectActionContext(root) {
+    var tokens = new Set();
+    var state = {
+        nestedAction: false
+    };
+    var walk = function walk1(node, isRoot) {
+        if (!node || (typeof node === "undefined" ? "undefined" : _type_of(node)) !== 'object') {
+            return;
+        }
+        if (!isRoot && isActionHost(node)) {
+            state.nestedAction = true;
+            return; // do not descend into a nested action context
+        }
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            for(var _iterator = elementTokenNames(node)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                var name = _step.value;
+                tokens.add(name);
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+        var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+        try {
+            for(var _iterator1 = DBX_ACTION_CHILD_LIST_KEYS[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                var key = _step1.value;
+                var children = node[key];
+                if (Array.isArray(children)) {
+                    var _iteratorNormalCompletion2 = true, _didIteratorError2 = false, _iteratorError2 = undefined;
+                    try {
+                        for(var _iterator2 = children[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true){
+                            var child = _step2.value;
+                            walk(child, false);
+                        }
+                    } catch (err) {
+                        _didIteratorError2 = true;
+                        _iteratorError2 = err;
+                    } finally{
+                        try {
+                            if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+                                _iterator2.return();
+                            }
+                        } finally{
+                            if (_didIteratorError2) {
+                                throw _iteratorError2;
+                            }
+                        }
+                    }
+                }
+            }
+        } catch (err) {
+            _didIteratorError1 = true;
+            _iteratorError1 = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                    _iterator1.return();
+                }
+            } finally{
+                if (_didIteratorError1) {
+                    throw _iteratorError1;
+                }
+            }
+        }
+        var _iteratorNormalCompletion3 = true, _didIteratorError3 = false, _iteratorError3 = undefined;
+        try {
+            for(var _iterator3 = DBX_ACTION_CHILD_NODE_KEYS[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true){
+                var key1 = _step3.value;
+                var child1 = node[key1];
+                if (child1 && (typeof child1 === "undefined" ? "undefined" : _type_of(child1)) === 'object') {
+                    walk(child1, false);
+                }
+            }
+        } catch (err) {
+            _didIteratorError3 = true;
+            _iteratorError3 = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion3 && _iterator3.return != null) {
+                    _iterator3.return();
+                }
+            } finally{
+                if (_didIteratorError3) {
+                    throw _iteratorError3;
+                }
+            }
+        }
+    };
+    walk(root, true);
+    return {
+        tokens: tokens,
+        nestedAction: state.nestedAction
+    };
+}
+/**
+ * Resolves the template parser services from the rule context, supporting both the
+ * flat-config `context.sourceCode` accessor and the legacy `context.parserServices`.
+ *
+ * @param context - The ESLint rule context.
+ * @returns The parser services object, or null when unavailable.
+ */ function getTemplateParserServices(context) {
+    var _context_sourceCode, _ref, _ref1;
+    var sourceCode = (_context_sourceCode = context.sourceCode) !== null && _context_sourceCode !== void 0 ? _context_sourceCode : typeof context.getSourceCode === 'function' ? context.getSourceCode() : undefined;
+    return (_ref = (_ref1 = sourceCode === null || sourceCode === void 0 ? void 0 : sourceCode.parserServices) !== null && _ref1 !== void 0 ? _ref1 : context.parserServices) !== null && _ref !== void 0 ? _ref : null;
+}
+/**
+ * Computes the report location for an action element from its source span.
+ *
+ * @param parserServices - The template parser services (must expose `convertNodeSourceSpanToLoc`).
+ * @param node - The element AST node being reported.
+ * @returns An ESLint `SourceLocation` for the element's opening tag.
+ */ function actionElementLoc(parserServices, node) {
+    var _node_startSourceSpan;
+    return parserServices.convertNodeSourceSpanToLoc((_node_startSourceSpan = node.startSourceSpan) !== null && _node_startSourceSpan !== void 0 ? _node_startSourceSpan : node.sourceSpan);
+}
+
+/**
+ * ESLint (Angular template) rule that flags a `dbxAction` whose context has a
+ * trigger but no value source.
+ *
+ * Such an action hangs: clicking the trigger moves the store to TRIGGERED, but with
+ * nothing to call `readyValue()` it never advances to VALUE_READY, so the handler
+ * never runs.
+ *
+ * Targets simple, inline cases only. It bails (does not report) when the value may
+ * be supplied in a way a static template scan cannot see:
+ * - `[dbxActionSource]` on the element or an ancestor (store forwarded from TS), or
+ * - a nested `dbxAction` inside the subtree (ambiguous which context owns a value source).
+ *
+ * For legitimate programmatic-value cases (or a demo intentionally showing the
+ * TRIGGERED state) suppress with `<!-- eslint-disable-next-line dereekb-dbx-web/require-action-value-source -->`.
+ */ var DBX_WEB_REQUIRE_ACTION_VALUE_SOURCE_RULE = {
+    meta: {
+        type: 'problem',
+        fixable: undefined,
+        docs: {
+            description: 'Require a value source on a triggered dbxAction so it cannot hang in the TRIGGERED state.',
+            recommended: true
+        },
+        messages: {
+            missingValueSource: '`dbxAction` has a trigger (`{{trigger}}`) but no value source, so triggering it hangs — the action never reaches VALUE_READY and the handler never runs. Add a value source (`dbxActionValue`, `[dbxActionValue]`, `[dbxActionValueGetter]`, `[dbxActionValueStream]`, or `[dbxActionForm]`), trigger with `triggerWithValue()`, or disable this line if the value is supplied in TypeScript.'
+        },
+        schema: []
+    },
+    create: function create(context) {
+        var parserServices = getTemplateParserServices(context);
+        return {
+            Element: function Element(node) {
+                if (!(parserServices === null || parserServices === void 0 ? void 0 : parserServices.convertNodeSourceSpanToLoc)) {
+                    return; // not an Angular template (no template parser services)
+                }
+                if (!isActionHost(node)) {
+                    return;
+                }
+                if (hasTokenOnSelfOrAncestor(node, DBX_ACTION_SOURCE_SELECTOR)) {
+                    return; // store/value may be forwarded from an external (TS) source
+                }
+                var _collectActionContext = collectActionContext(node), tokens = _collectActionContext.tokens, nestedAction = _collectActionContext.nestedAction;
+                if (nestedAction) {
+                    return; // multiple action contexts — ambiguous which owns a value source
+                }
+                var trigger = DBX_ACTION_TRIGGER_SELECTORS.find(function(selector) {
+                    return tokens.has(selector);
+                });
+                if (!trigger) {
+                    return; // not trigger-driven (form/auto/programmatic) — out of scope
+                }
+                var hasValueSource = DBX_ACTION_VALUE_SOURCE_SELECTORS.some(function(selector) {
+                    return tokens.has(selector);
+                });
+                if (!hasValueSource) {
+                    context.report({
+                        loc: actionElementLoc(parserServices, node),
+                        messageId: 'missingValueSource',
+                        data: {
+                            trigger: trigger
+                        }
+                    });
+                }
+            }
+        };
+    }
+};
+
+/**
+ * ESLint (Angular template) rule that flags a `dbxAction` which runs work (has a
+ * handler or a trigger) but presents no errors to the user.
+ *
+ * Satisfied by ANY error directive in the context: `dbxActionSnackbarError`,
+ * `[dbxActionError]`, `[dbxActionSnackbar]`, or `[dbxActionErrorHandler]`.
+ *
+ * Shares the same context-scoping bail conditions as `require-action-value-source`
+ * (`[dbxActionSource]` on self/ancestor, or a nested `dbxAction`).
+ */ var DBX_WEB_REQUIRE_ACTION_ERROR_HANDLER_RULE = {
+    meta: {
+        type: 'suggestion',
+        fixable: undefined,
+        docs: {
+            description: 'Require an error-presentation directive on a dbxAction that runs a handler so failures surface to the user.',
+            recommended: false
+        },
+        messages: {
+            missingErrorHandler: '`dbxAction` runs a handler but surfaces no errors to the user. Add `dbxActionSnackbarError` (or `[dbxActionError]`, `[dbxActionSnackbar]`, or `[dbxActionErrorHandler]`) so action failures are presented.'
+        },
+        schema: []
+    },
+    create: function create(context) {
+        var parserServices = getTemplateParserServices(context);
+        return {
+            Element: function Element(node) {
+                if (!(parserServices === null || parserServices === void 0 ? void 0 : parserServices.convertNodeSourceSpanToLoc)) {
+                    return; // not an Angular template (no template parser services)
+                }
+                if (!isActionHost(node)) {
+                    return;
+                }
+                if (hasTokenOnSelfOrAncestor(node, DBX_ACTION_SOURCE_SELECTOR)) {
+                    return; // forwarded external context — error handling may live elsewhere
+                }
+                var _collectActionContext = collectActionContext(node), tokens = _collectActionContext.tokens, nestedAction = _collectActionContext.nestedAction;
+                if (nestedAction) {
+                    return; // multiple action contexts — ambiguous
+                }
+                var hasHandlerOrTrigger = tokens.has(DBX_ACTION_HANDLER_SELECTOR) || DBX_ACTION_TRIGGER_SELECTORS.some(function(selector) {
+                    return tokens.has(selector);
+                });
+                if (!hasHandlerOrTrigger) {
+                    return; // nothing actionable here — skip
+                }
+                var hasErrorDirective = DBX_ACTION_ERROR_DIRECTIVE_SELECTORS.some(function(selector) {
+                    return tokens.has(selector);
+                });
+                if (!hasErrorDirective) {
+                    context.report({
+                        loc: actionElementLoc(parserServices, node),
+                        messageId: 'missingErrorHandler'
+                    });
+                }
+            }
+        };
+    }
+};
+
 /**
  * ESLint plugin for dbx-web rules.
  *
@@ -2528,7 +2933,9 @@ function _unsupported_iterable_to_array(o, minLen) {
         'no-redundant-on-destroy': DBX_WEB_NO_REDUNDANT_ON_DESTROY_RULE,
         'require-computed-signal-suffix': DBX_WEB_REQUIRE_COMPUTED_SIGNAL_SUFFIX_RULE,
         'require-component-config-input': DBX_WEB_REQUIRE_COMPONENT_CONFIG_INPUT_RULE,
-        'require-top-level-computed-signals': DBX_WEB_REQUIRE_TOP_LEVEL_COMPUTED_SIGNALS_RULE
+        'require-top-level-computed-signals': DBX_WEB_REQUIRE_TOP_LEVEL_COMPUTED_SIGNALS_RULE,
+        'require-action-value-source': DBX_WEB_REQUIRE_ACTION_VALUE_SOURCE_RULE,
+        'require-action-error-handler': DBX_WEB_REQUIRE_ACTION_ERROR_HANDLER_RULE
     }
 };
 /**
@@ -2539,6 +2946,8 @@ function _unsupported_iterable_to_array(o, minLen) {
 
 exports.DBX_WEB_ESLINT_PLUGIN = DBX_WEB_ESLINT_PLUGIN;
 exports.DBX_WEB_NO_REDUNDANT_ON_DESTROY_RULE = DBX_WEB_NO_REDUNDANT_ON_DESTROY_RULE;
+exports.DBX_WEB_REQUIRE_ACTION_ERROR_HANDLER_RULE = DBX_WEB_REQUIRE_ACTION_ERROR_HANDLER_RULE;
+exports.DBX_WEB_REQUIRE_ACTION_VALUE_SOURCE_RULE = DBX_WEB_REQUIRE_ACTION_VALUE_SOURCE_RULE;
 exports.DBX_WEB_REQUIRE_CLEAN_SUBSCRIPTION_RULE = DBX_WEB_REQUIRE_CLEAN_SUBSCRIPTION_RULE;
 exports.DBX_WEB_REQUIRE_COMPLETE_ON_DESTROY_RULE = DBX_WEB_REQUIRE_COMPLETE_ON_DESTROY_RULE;
 exports.DBX_WEB_REQUIRE_COMPONENT_CONFIG_INPUT_RULE = DBX_WEB_REQUIRE_COMPONENT_CONFIG_INPUT_RULE;