@heartlandone/vega 1.1.0 → 1.3.0

package/dist/cjs/accessibility-34d46f85.js

@@ -0,0 +1,16 @@
+'use strict';
+
+/**
+ * It returns a function that takes a KeyboardEvent and dispatches a click event on the currentTarget if the key is Enter.
+ *
+ * @returns {(e: KeyboardEvent) => void } A function that takes a KeyboardEvent and dispatches a click event on the currentTarget.
+ */
+function createEnterKeyHandlerToTriggerClick() {
+  return function (e) {
+    if (e.key === 'Enter') {
+      e.currentTarget.dispatchEvent(new MouseEvent('click', { bubbles: true, cancelable: true, view: window }));
+    }
+  };
+}
+
+exports.createEnterKeyHandlerToTriggerClick = createEnterKeyHandlerToTriggerClick;

package/dist/cjs/app-globals-3109659d.js

@@ -0,0 +1,23 @@
+'use strict';
+
+const featureFlagController = require('./featureFlagController-0fbc9f6a.js');
+
+/**
+ * Default export function that will be used by stencil global script,
+ * which will be invoked before library loaded.
+ */
+function appGlobalScript () {
+  disableFeatureFlagFromClientGlobal();
+}
+/**
+ * Disable feature flags from the client global defined lists.
+ */
+function disableFeatureFlagFromClientGlobal() {
+  if (globalThis['VegaDisabledFeatureKeys']) {
+    featureFlagController.FeatureFlag.disable(...globalThis['VegaDisabledFeatureKeys']);
+  }
+}
+
+const globalScripts = appGlobalScript;
+
+exports.globalScripts = globalScripts;

package/dist/cjs/array-414f6d01.js

@@ -0,0 +1,45 @@
+'use strict';
+
+const number = require('./number-2eb7b8f3.js');
+
+/**
+ * It flattens an array of objects
+ *
+ * @typedef T generic type  parameter
+ * @param {T[]} arr - The array to be flattened.
+ * @param {string} [children=children] - The name of the key that contains the children.
+ * @returns {T[]}An array of all the children of the array of items.
+ */
+const flattenChildren = (arr, children = 'children') => {
+  return arr.reduce((result, item) => result.concat(item[children] ? flattenChildren(item[children], children) : item), []);
+};
+/**
+ * Compare if the two arrays are equal or not
+ *
+ * @param {T[]} first - T[] - The first array to compare.
+ * @param {T[]} second - T[] - The second array to compare to the first.
+ * @returns {boolean} It returns true if the two arrays are equal, and false if they are not
+ */
+const isArrayEqual = (first, second) => {
+  if (!Array.isArray(first) || !Array.isArray(second) || first.length != second.length)
+    return false;
+  for (let i = 0; i < first.length; i++) {
+    if (first[i] !== second[i]) {
+      return false;
+    }
+  }
+  return true;
+};
+/**
+ * Return true if all the keys of the object are numbers since it's an array-like object, false otherwise.
+ *
+ * @param {Record<string, unknown>} obj - The object to check.
+ * @returns {boolean} boolean indicating if the object is array-like
+ */
+const isObjectArrayLike = (obj) => {
+  return Object.keys(obj).every((key) => !isNaN(number.convertToNumber(key)));
+};
+
+exports.flattenChildren = flattenChildren;
+exports.isArrayEqual = isArrayEqual;
+exports.isObjectArrayLike = isObjectArrayLike;

package/dist/cjs/component-4cd0485c.js

@@ -0,0 +1,84 @@
+'use strict';
+
+const log = require('./log-7b0974fb.js');
+
+const exemptionClasses = [
+  'vega-flex-grow',
+  'vega-flex-shrink',
+  'vega-flex-grow-0',
+  'vega-flex-shrink-0',
+  'vega-flex-basis-0',
+  'v-min-w-min',
+];
+/**
+ * Sanitize the vega component rendered output hostElement with the following procedures:
+ * 1. Catch any external passed-in classes e.g. <vega-flex class="<culprit_class>"></vega-flex>
+ *    and log error message
+ * 2. Persist the verified classes into DOM element dataset['verifiedClasses'] for the next time verification
+ * 3. Catch any data-shrink='0' attribute e.g. <vega-flex><div data-shrink='0'></div></vega-flex> and log error message
+ *
+ * @typedef T type of vega component
+ * @param {T} renderedOutput renderedOutput generated internally by vega-component runtime
+ * @param {HTMLStencilElement} hostElement the external-facing element reference for hosting the vega component renderedOutput
+ * @returns {T} processed vega component
+ */
+function sanitizeVegaComponent(renderedOutput, hostElement) {
+  checkIfInAllowedClassList(renderedOutput, hostElement);
+  checkIfUseDataShrink(hostElement);
+  return renderedOutput;
+}
+/**
+ * It checks if the classes added to the host element are allowed
+ *
+ * @param {T} renderedOutput - T - The output of the render method of the component
+ * @param {HTMLStencilElement} hostElement - HTMLStencilElement - the host element of the component
+ */
+function checkIfInAllowedClassList(renderedOutput, hostElement) {
+  var _a, _b, _c;
+  // Get classes passed from vega component render method
+  const componentDefinedClasses = ['hydrated'].concat(((_b = (_a = renderedOutput['$attrs$']) === null || _a === void 0 ? void 0 : _a['class']) === null || _b === void 0 ? void 0 : _b.split(/\s+/).filter(Boolean)) || []);
+  // Get previously verified (and rendered in DOM tree) classes
+  const previousVerifiedClasses = ((_c = hostElement.dataset['verifiedClasses']) === null || _c === void 0 ? void 0 : _c.split(' ')) || [];
+  // Construct the classes allowlist
+  const allowlistClassSet = new Set([
+    ...componentDefinedClasses,
+    ...previousVerifiedClasses,
+    ...exemptionClasses,
+  ]);
+  // Get the culprit classes
+  const culpritClassTokens = Array.from(hostElement.classList)
+    .filter(Boolean)
+    //Exclude the classes with breakpoint prefixes (M:vega-flex-shrink for example) from the culprit list
+    .filter((classStr) => {
+    const classStrWithoutBreakpoint = classStr.replace(/(S|M|L|XL):/, '');
+    return !allowlistClassSet.has(classStrWithoutBreakpoint);
+  })
+    //Exclude the classes added by the framework (Angular for example) from the culprit list
+    .filter((classStr) => !classStr.startsWith('ng-'));
+  if (culpritClassTokens.length) {
+    // For now, we will show a warning instead of erasing the culprit classes
+    log.LogUtility.error(`Found class(es) ${culpritClassTokens} added to component:`, hostElement, ' which is anti vega design pattern and we will forbid this behavior in the future release.', ' for more details, please refer to: https://heartland1.gitlab.io/vega/tiger/?path=/docs/other-best-practice--page');
+    // hostElement.classList.remove(...culpritClassTokens);
+  }
+  // Persist the verified classes for the next time verification
+  if (componentDefinedClasses.join() !== 'hydrated') {
+    hostElement.dataset['verifiedClasses'] = componentDefinedClasses.join(' ');
+  }
+}
+/**
+ * It checks if the host element has any children with the attribute data-shrink. If it does, it logs an error
+ *
+ * @param {HTMLStencilElement} hostElement - HTMLStencilElement - the host element of the component
+ */
+function checkIfUseDataShrink(hostElement) {
+  if (hostElement.children) {
+    const children = Array.from(hostElement.children);
+    children.forEach((child) => {
+      if (child.hasAttribute('data-shrink')) {
+        log.LogUtility.error(`Found attribute [data-shrink='0'] inside component:`, hostElement, ' which will be deprecated, please use classes of vega-flex-shrink, vega-flex-grow, vega-flex-shrink-0, vega-flex-grow-0, vega-flex-basis-0 instead.');
+      }
+    });
+  }
+}
+
+exports.sanitizeVegaComponent = sanitizeVegaComponent;