@heartlandone/vega 1.44.1 → 1.44.2

package/dist/cjs/{formFieldController-e17becdd.js → formFieldControllerSlimmer-e59c7d68.js}

@@ -1,5 +1,9 @@
 'use strict';
 
+const vegaSlimmer = require('./vega-slimmer-e47c8e62.js');
+const mapToComponentMethod = require('./map-to-component-method-59546991.js');
+const featureFlagController = require('./featureFlagController-1ed087d2.js');
+const string = require('./string-21427167.js');
 const changeManager = require('./changeManager-db6724a9.js');
 const observer = require('./observer-126f19d0.js');
 const ui = require('./ui-824caf47.js');
@@ -593,4 +597,211 @@ class FormFieldController {
   }
 }
 
-exports.FormFieldController = FormFieldController;
+var __decorate = (undefined && undefined.__decorate) || function (decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+/**
+ * The `FormFieldControllerSlimmer` class is a TypeScript class that extends `VegaSlimmer` and provides functionality for managing form field components.
+ * TODO:
+ * 1.Apply formFieldController to slimmer
+ * 2.There should be a decorator or other type to access the component interface for the `attributeGetter`
+ */
+class FormFieldControllerSlimmer extends vegaSlimmer.VegaSlimmer {
+  /**
+   * The constructor function initializes a FormFieldOptionForSlimmer object with the provided options.
+   *
+   * @param {FormFieldOptionForSlimmer<unknown>} options - The `options` parameter is an object of type `FormFieldOptionForSlimmer<T>`. It is used to
+   * provide additional configuration options for the form field. The specific properties and their
+   * types within the `FormFieldOptionForSlimmer` object would depend on the implementation of the `FormField` class.
+   */
+  constructor(options) {
+    super();
+    this.options = options;
+  }
+  /**
+   * "If the element exists and has a data-vega-form attribute, return true, otherwise return false."
+   * The function isValidFormField() is used to determine if an element is a form field
+   *
+   * @param {HTMLElement} element - The element to check.
+   * @returns {boolean} A function that takes an element and returns a boolean.
+   */
+  static isValidFormField(element) {
+    return element && Boolean(element.getAttribute('data-vega-form'));
+  }
+  /**
+   * watch the prop validationRules and call the valid method
+   * some components has not a prop validationRules
+   */
+  watchValidationRulesByFormControllerSlimmer() {
+    this.setAdditionalRules();
+    this.internalValidate();
+  }
+  /**
+   * call the method when the component call valid method
+   *
+   * @param {boolean | 'rule'} showError show error message or not
+   * @returns {Promise<boolean>} the validation result
+   */
+  validByFormControllerSlimmer(showError = true) {
+    var _a;
+    return (_a = this.validator) === null || _a === void 0 ? void 0 : _a.validate(showError);
+  }
+  /**
+   * listen the attributes change when connectedCallback method call
+   */
+  connectedCallbackByFormFieldSlimmer() {
+    if (this.validator === null) {
+      this.setInjectFormFieldHelper();
+      this.observeDefaultRuleAttributes();
+    }
+  }
+  /**
+   * destroy the form field helper when disconnectedCallback method call
+   */
+  disconnectedCallbackByFormFieldSlimmer() {
+    this.destroy();
+  }
+  /**
+   * inject form file help when componentWillLoad method call
+   */
+  componentWillLoadByFormFieldSlimmer() {
+    this.setInjectFormFieldHelper();
+  }
+  /**
+   * listen the attributes change when componentDidLoad method call
+   */
+  componentDidLoadByFormFieldSlimmer() {
+    this.observeDefaultRuleAttributes();
+  }
+  /**
+   * "If the target is not disabled, then call the validate function on the target's validator
+   * property."
+   *
+   * The validator property is a property that we'll add to the target element. It's a property that
+   * will hold a reference to the validator object that we'll create
+   */
+  internalValidate() {
+    if (!this.disabled && this.validator) {
+      void this.validator.validate();
+    }
+  }
+  /* eslint-disable jsdoc/require-jsdoc */
+  setInjectFormFieldHelper() {
+    const isFeatureEnabled = featureFlagController.FeatureFlag.isEnabled('VEGA_INJECT_FORM_FIELD_CONTROLLER.ADD_DATA_VEGA_FORM_FILTER');
+    if (!isFeatureEnabled ||
+      (isFeatureEnabled && FormFieldControllerSlimmer.isValidFormField(this.host))) {
+      const { defaultValue, inputContainerSelector, touchableAreaSelector, } = this.options;
+      const validator = new FormFieldController(this.getPropertyRules(), this.host, defaultValue, inputContainerSelector, touchableAreaSelector);
+      validator.addListener({
+        /* eslint-disable jsdoc/require-jsdoc */
+        callback: (isValid) => {
+          if (this.isValid != isValid) {
+            this.isValid = isValid;
+            this.vegaValidate && this.vegaValidate.emit(isValid);
+          }
+        },
+      });
+      this.validator = validator;
+      this.setAdditionalRules();
+    }
+  }
+  /**
+   * It sets up an observer that watches for changes to the attributes of the form field element
+   * attributes: required, min, max...
+   */
+  observeDefaultRuleAttributes() {
+    if (this.validator) {
+      this.formFieldAttributesObserver || (this.formFieldAttributesObserver = new MutationObserver(async () => {
+        this.setDefaultRules();
+        this.internalValidate();
+      }));
+      const watchProperties = this.options.propertyRules.map((rule) => string.camelToDashCase(rule.propertyName));
+      this.formFieldAttributesObserver.observe(this.host, {
+        attributeFilter: watchProperties,
+      });
+    }
+  }
+  /**
+   * It destroys the validator and disconnects the observer
+   */
+  destroy() {
+    if (this.validator) {
+      this.validator.destroy();
+      this.formFieldAttributesObserver.disconnect();
+      this.validator = null;
+      this.formFieldAttributesObserver = null;
+    }
+  }
+  /**
+   * It sets the additional rules on the validator
+   */
+  setAdditionalRules() {
+    if (this.options.validationRulesName &&
+      this.options.validationRulesName === 'validationRules' &&
+      this.validator) {
+      this.validator.setAdditionalRules(this.validationRules || []);
+    }
+  }
+  /**
+   * It creates a new rule for each property rule map option, and then sets the default rules on the
+   * target's validator
+   */
+  setDefaultRules() {
+    if (this.validator) {
+      this.validator.setDefaultRules(this.getPropertyRules());
+    }
+  }
+  /**
+   * It takes the property rules from the option, maps them to a function that returns a validation rule,
+   * and then filters out any falsy values
+   *
+   * @returns {FormFieldValidationRule[]} An array of validation rules.
+   */
+  getPropertyRules() {
+    const { propertyRules, attributeGetter } = this.options;
+    return propertyRules
+      .map((rule) => rule.ruleFactory(attributeGetter(rule.propertyName), rule.dependence ? attributeGetter(rule.dependence) : null))
+      .filter(Boolean);
+  }
+}
+__decorate([
+  vegaSlimmer.MapToComponentField()
+], FormFieldControllerSlimmer.prototype, "host", void 0);
+__decorate([
+  vegaSlimmer.MapToComponentField({ writable: true })
+], FormFieldControllerSlimmer.prototype, "validationRules", void 0);
+__decorate([
+  vegaSlimmer.MapToComponentField()
+], FormFieldControllerSlimmer.prototype, "disabled", void 0);
+__decorate([
+  vegaSlimmer.MapToComponentField()
+], FormFieldControllerSlimmer.prototype, "autoValidation", void 0);
+__decorate([
+  vegaSlimmer.MapToComponentField({ writable: true })
+], FormFieldControllerSlimmer.prototype, "isValid", void 0);
+__decorate([
+  vegaSlimmer.MapToComponentField()
+], FormFieldControllerSlimmer.prototype, "vegaValidate", void 0);
+__decorate([
+  mapToComponentMethod.MapToComponentMethod('watchValidationRules')
+], FormFieldControllerSlimmer.prototype, "watchValidationRulesByFormControllerSlimmer", null);
+__decorate([
+  mapToComponentMethod.MapToComponentMethod('valid')
+], FormFieldControllerSlimmer.prototype, "validByFormControllerSlimmer", null);
+__decorate([
+  mapToComponentMethod.MapToComponentMethod('connectedCallback')
+], FormFieldControllerSlimmer.prototype, "connectedCallbackByFormFieldSlimmer", null);
+__decorate([
+  mapToComponentMethod.MapToComponentMethod('disconnectedCallback')
+], FormFieldControllerSlimmer.prototype, "disconnectedCallbackByFormFieldSlimmer", null);
+__decorate([
+  mapToComponentMethod.MapToComponentMethod('componentWillLoad')
+], FormFieldControllerSlimmer.prototype, "componentWillLoadByFormFieldSlimmer", null);
+__decorate([
+  mapToComponentMethod.MapToComponentMethod('componentDidLoad')
+], FormFieldControllerSlimmer.prototype, "componentDidLoadByFormFieldSlimmer", null);
+
+exports.FormFieldControllerSlimmer = FormFieldControllerSlimmer;

package/dist/cjs/inject-vega-slimmer-7fbd8e58.js

@@ -0,0 +1,79 @@
+'use strict';
+
+const vegaSlimmer = require('./vega-slimmer-e47c8e62.js');
+
+/**
+ * This decorator is used to re-define a field in a vega component
+ * which will be used for injecting the VegaSlimmer into the vega component.
+ *
+ * @returns {Function} The decorator function.
+ */
+function InjectVegaSlimmer() {
+    return function (componentPrototype, propertyKey) {
+        Object.defineProperty(componentPrototype, propertyKey, {
+            set: createSetterForVegaSlimmerField(propertyKey),
+            get: createGetterForVegaSlimmerField(propertyKey),
+        });
+    };
+}
+/**
+ * Creates a setter for a vega slimmer field which will be used for injecting the VegaSlimmer into the vega component.
+ *
+ * @param {string} fieldName The name of the field to inject the VegaSlimmer into.
+ * @returns {Function} A setter for the vega slimmer field.
+ */
+function createSetterForVegaSlimmerField(fieldName) {
+    return function (slimmer) {
+        if (!this[vegaSlimmer.ConsumerSlimmers]) {
+            this[vegaSlimmer.ConsumerSlimmers] = new Map();
+        }
+        this[vegaSlimmer.ConsumerSlimmers].set(fieldName, slimmer);
+        slimmer[vegaSlimmer.SlimmerConsumedBy] = this;
+        registerSlimMethodsToComponent(slimmer, this);
+    };
+}
+/**
+ * Creates a getter for a vega slimmer field which will be used for injecting the VegaSlimmer into the vega component.
+ *
+ * @param {string} fieldName The name of the field to inject the VegaSlimmer into.
+ * @returns {Function} A getter for the vega slimmer field.
+ */
+function createGetterForVegaSlimmerField(fieldName) {
+    return function () {
+        return this[vegaSlimmer.ConsumerSlimmers].get(fieldName);
+    };
+}
+/**
+ * Given a VegaSlimmer and a component, register the slimmer methods to the component.
+ * This is done by appending the slimmer methods to the end of the corresponding component method.
+ *
+ * @param {VegaSlimmer} slimmer The slimmer to register the slimmer method to.
+ * @param {ComponentInterface} component The component to register the slimmer method to.
+ * @returns {void}
+ */
+function registerSlimMethodsToComponent(slimmer, component) {
+    const slimmerPrototype = slimmer.constructor.prototype;
+    if (slimmerPrototype[vegaSlimmer.SlimmerMappedMethod]) {
+        for (const entry of slimmerPrototype[vegaSlimmer.SlimmerMappedMethod]) {
+            component[entry.componentMethodName] = createRegisteredSlimMethod(component, slimmer, component[entry.componentMethodName], entry);
+        }
+    }
+}
+/**
+ * Append the slimmer methods to the end of the corresponding component method.
+ * Which means the slimmer method will be called when the original method is invoked in the component.
+ *
+ * @param {ComponentInterface} component The component to register the slimmer method to.
+ * @param {VegaSlimmer} slimmer The slimmer to register the slimmer method to.
+ * @param {Function} originalMethod The original method to override.
+ * @param {SlimmerMappedMethodEntry} mapEntry The map entry for the slimmer method.
+ * @returns {Function} The registered slimmer method.
+ */
+function createRegisteredSlimMethod(component, slimmer, originalMethod, mapEntry) {
+    return function (...args) {
+        originalMethod === null || originalMethod === void 0 ? void 0 : originalMethod.apply(component, args);
+        return slimmer[mapEntry.slimmerMethodName].call(slimmer, ...args);
+    };
+}
+
+exports.InjectVegaSlimmer = InjectVegaSlimmer;

package/dist/cjs/{map-to-component-method-a3eb6fe7.js → map-to-component-method-59546991.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-const vegaSlimmer = require('./vega-slimmer-5503957a.js');
+const vegaSlimmer = require('./vega-slimmer-e47c8e62.js');
 
 /**
  * The function `MapToComponentMethod` is a TypeScript decorator that maps a method in a class to a

package/dist/cjs/{pageResizeObserverSlimmer-7b169e3e.js → pageResizeObserverSlimmer-1de5259c.js}

@@ -1,7 +1,7 @@
 'use strict';
 
-const vegaSlimmer = require('./vega-slimmer-5503957a.js');
-const mapToComponentMethod = require('./map-to-component-method-a3eb6fe7.js');
+const vegaSlimmer = require('./vega-slimmer-e47c8e62.js');
+const mapToComponentMethod = require('./map-to-component-method-59546991.js');
 const breakpoints = require('./breakpoints-07fcbeba.js');
 
 var __decorate = (undefined && undefined.__decorate) || function (decorators, target, key, desc) {

package/dist/cjs/vega-accordion.cjs.entry.js

@@ -3,7 +3,8 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 const index = require('./index-0ca30e90.js');
-const vegaSlimmer = require('./vega-slimmer-5503957a.js');
+const vegaSlimmer = require('./vega-slimmer-e47c8e62.js');
+const injectVegaSlimmer = require('./inject-vega-slimmer-7fbd8e58.js');
 const placeholder = require('./placeholder-1d8034a7.js');
 const component = require('./component-a51251c5.js');
 require('./log-5d8066e0.js');
@@ -11,7 +12,7 @@ const designToken = require('./designToken-a50a38a4.js');
 const ui = require('./ui-824caf47.js');
 const observer = require('./observer-126f19d0.js');
 const changeManager = require('./changeManager-db6724a9.js');
-const mapToComponentMethod = require('./map-to-component-method-a3eb6fe7.js');
+const mapToComponentMethod = require('./map-to-component-method-59546991.js');
 const typeGuard = require('./typeGuard-9a59ac0e.js');
 require('./featureFlagController-1ed087d2.js');
 require('./breakpoints-23bb4f74.js');
@@ -227,10 +228,10 @@ const VegaAccordion = class {
   }; }
 };
 __decorate([
-  vegaSlimmer.InjectVegaSlimmer()
+  injectVegaSlimmer.InjectVegaSlimmer()
 ], VegaAccordion.prototype, "renderer", void 0);
 __decorate([
-  vegaSlimmer.InjectVegaSlimmer()
+  injectVegaSlimmer.InjectVegaSlimmer()
 ], VegaAccordion.prototype, "expandController", void 0);
 
 exports.vega_accordion = VegaAccordion;

package/dist/cjs/vega-app-header-button.cjs.entry.js

@@ -9,15 +9,16 @@ const designToken = require('./designToken-a50a38a4.js');
 const responsiveFormatFacade = require('./responsiveFormatFacade-0277ef3c.js');
 const log = require('./log-5d8066e0.js');
 const breakpoints = require('./breakpoints-07fcbeba.js');
-const vegaSlimmer = require('./vega-slimmer-5503957a.js');
-const pageResizeObserverSlimmer = require('./pageResizeObserverSlimmer-7b169e3e.js');
+require('./vega-slimmer-e47c8e62.js');
+const injectVegaSlimmer = require('./inject-vega-slimmer-7fbd8e58.js');
+const pageResizeObserverSlimmer = require('./pageResizeObserverSlimmer-1de5259c.js');
 require('./featureFlagController-1ed087d2.js');
 require('./ui.type-655d8879.js');
 require('./typeGuard-9a59ac0e.js');
 require('./breakpoints-23bb4f74.js');
 require('./ui-bac156c5.js');
 require('./number-7e7d9981.js');
-require('./map-to-component-method-a3eb6fe7.js');
+require('./map-to-component-method-59546991.js');
 
 var __decorate = (undefined && undefined.__decorate) || function (decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
@@ -203,7 +204,7 @@ const VegaAppHeaderButton = class {
   }; }
 };
 __decorate([
-  vegaSlimmer.InjectVegaSlimmer()
+  injectVegaSlimmer.InjectVegaSlimmer()
 ], VegaAppHeaderButton.prototype, "pageResizeObserverSlimmer", void 0);
 
 exports.vega_app_header_button = VegaAppHeaderButton;

package/dist/cjs/vega-badge.cjs.entry.js

@@ -8,8 +8,9 @@ const designToken = require('./designToken-a50a38a4.js');
 const ui = require('./ui-824caf47.js');
 const responsiveFormatFacade = require('./responsiveFormatFacade-0277ef3c.js');
 const breakpoints = require('./breakpoints-07fcbeba.js');
-const vegaSlimmer = require('./vega-slimmer-5503957a.js');
-const pageResizeObserverSlimmer = require('./pageResizeObserverSlimmer-7b169e3e.js');
+require('./vega-slimmer-e47c8e62.js');
+const injectVegaSlimmer = require('./inject-vega-slimmer-7fbd8e58.js');
+const pageResizeObserverSlimmer = require('./pageResizeObserverSlimmer-1de5259c.js');
 require('./featureFlagController-1ed087d2.js');
 require('./log-5d8066e0.js');
 require('./typeGuard-9a59ac0e.js');
@@ -17,7 +18,7 @@ require('./breakpoints-23bb4f74.js');
 require('./ui-bac156c5.js');
 require('./ui.type-655d8879.js');
 require('./number-7e7d9981.js');
-require('./map-to-component-method-a3eb6fe7.js');
+require('./map-to-component-method-59546991.js');
 
 const vegaBadgeCss = "vega-badge {\n\t@apply v-inline-block;\n}\n\nvega-badge .vega-badge {\n\t@apply v-inline-flex v-items-center v-justify-center v-rounded-full v-box-border;\n\t@apply v-h-size-40 v-px-size-16 v-py-size-8 v-font-field-label-em;\n}\n\nvega-badge .vega-badge.default {\n\t@apply v-h-size-40 v-px-size-16 v-py-size-8 v-font-field-label-em v-min-w-size-40;\n}\n\nvega-badge .vega-badge.large {\n\t@apply v-h-size-64 v-px-size-24 v-py-size-16 v-font-h4 v-min-w-size-64;\n}\n\nvega-badge .vega-badge.small {\n\t@apply v-px-size-12 v-py-size-4 v-font-field-label-sm-em;\n\theight: 26px;\n\tmin-width: 26px;\n}\n";
 
@@ -65,7 +66,7 @@ const VegaBadge = class {
   get host() { return index.getElement(this); }
 };
 __decorate([
-  vegaSlimmer.InjectVegaSlimmer()
+  injectVegaSlimmer.InjectVegaSlimmer()
 ], VegaBadge.prototype, "pageResizeObserverSlimmer", void 0);
 VegaBadge.style = vegaBadgeCss;