@heartlandone/vega-sandbox-pr-1525-a1131d0b9c266e13a8d224ec5db9f11524d2d02c 2.28.0

package/dist/cjs/number-459031f7.js

@@ -0,0 +1,92 @@
+'use strict';
+
+/**
+ * "If the input is a number, return it, otherwise try to convert it to a number, and if that fails,
+ * return the fallback value."
+ *
+ * @param {unknown} input - The value to convert to a number.
+ * @param {number} [fallbackValue] - The value to return if the input is not a number.
+ * @returns {number} A function that takes two parameters, input and fallbackValue.
+ */
+const convertToNumber = (input, fallbackValue) => {
+  const convertedValue = Number(input);
+  return isNaN(convertedValue) ? Number(fallbackValue) : convertedValue;
+};
+/**
+ * Given an input string, check if the string match the size percentage format.
+ *
+ * @param {string} input - size string
+ * @returns {boolean} - size percentage format validation
+ */
+const isValidPercentage = (input) => {
+  const reg = /^\d+(?:\.\d+)?%$/;
+  return reg.test(input);
+};
+/**
+ * It returns the input number, unless it's less than the minimum, in which case it returns the
+ * minimum, or more than the maximum, in which case it returns the maximum.
+ *
+ * @param {number} input - The number to be normalized.
+ * @param {number} [min] - The minimum value that the input can be.
+ * @param {number} [max] - The maximum value that the number can be.
+ * @returns {number} A function that takes in a number, a min, and a max and returns a number.
+ */
+const normalizeNumberByRanger = (input, min, max) => {
+  let result = input;
+  if (typeof min === 'number') {
+    result = Math.max(min, result);
+  }
+  if (typeof max === 'number') {
+    result = Math.min(max, result);
+  }
+  return result;
+};
+/**
+ * Divide the value by 10, truncate the result, and add the remainder of the division to the truncated result.
+ *
+ * @param {number} value - number - The number to calculate the parity digit sum for.
+ * @returns {number} - return the formatted number
+ */
+const parityDigitSum = (value) => Math.trunc(value / 10) + (value % 10);
+/**
+ * The sum function takes two numbers and returns the sum of those two numbers.
+ *
+ * @param {number} accumulator - The accumulator accumulates the callback's return values; it is the
+ * accumulated value previously returned in the last invocation of the callback, or initialValue, if
+ * supplied (see below).
+ * @param {number} value - The current element being processed in the array.
+ * @returns {number} - return the calculated sum
+ */
+const sum = (accumulator, value) => (accumulator += value);
+/**
+ * "Given a string, return an array of numbers that are in the string."
+ *
+ * The function is written in TypeScript, but it's not too hard to understand even if you don't know
+ * TypeScript
+ *
+ * @param {string} value - string - The value that is passed in from the input field.
+ * @returns {number[]} - return a number[]
+ */
+const mapStringToNumberArray = (value) => value
+  .split('')
+  .filter((v) => /\d/.test(v))
+  .map((v) => Number(v));
+/**
+ * "Given an array of numbers, and a strategy for determining which numbers to double, return an array
+ * of numbers with the doubled numbers summed."
+ *
+ * The strategy is a function that takes an index and returns a boolean. The strategy is used to
+ * determine which numbers to double
+ *
+ * @param {number[]} values - number[] - an array of numbers to be summed
+ * @param {(index: number) => boolean} strategy - (index: number) => boolean
+ * @returns {number[]} - return a number[]
+ */
+const mapParityDigits = (values, strategy) => values.map((v, index) => (strategy(index) ? v : parityDigitSum(v * 2)));
+
+exports.convertToNumber = convertToNumber;
+exports.isValidPercentage = isValidPercentage;
+exports.mapParityDigits = mapParityDigits;
+exports.mapStringToNumberArray = mapStringToNumberArray;
+exports.normalizeNumberByRanger = normalizeNumberByRanger;
+exports.sum = sum;

package/dist/cjs/object-bbd4ed7f.js

@@ -0,0 +1,37 @@
+'use strict';
+
+/**
+ * It takes a record / HTMLElement and a path, and returns the value at that path
+ *
+ * @param {Record<string, unknown> | HTMLElement} record - The record object or HTMLElement that you want to get the value from.
+ * @param {string} path - The path to the value you want to get.
+ * @returns {unknown} The value of the path in the record.
+ */
+function getValueByPath(record, path = '') {
+  if (path.includes('.') && path !== '.') {
+    return path.split('.').reduce((pre, cur) => pre === null || pre === void 0 ? void 0 : pre[cur], record);
+  }
+  return record[path];
+}
+/**
+ * The `deepEqual` function compares two objects deeply to determine if they are equal.
+ *
+ * @param {unknown} obj - `obj` is the first object you want to compare for deep equality.
+ * @param {unknown} compareTo - The `compareTo` parameter is the object that you want to compare for
+ * deep equality with the `obj` parameter.
+ * @returns {boolean} The `deepEqual` function is returning a boolean value indicating whether the two input
+ * objects `obj` and `compareTo` are deeply equal. It checks if both inputs are objects, have the same
+ * number of keys, and recursively compares the key-value pairs to determine equality. If the objects
+ * are not objects, it directly compares them for equality.
+ */
+function deepEqual(obj, compareTo) {
+  return obj && compareTo && typeof obj === 'object' && typeof compareTo === 'object'
+    ? Object.keys(obj).length === Object.keys(compareTo).length &&
+      Object.keys(obj).reduce(function (isEqual, key) {
+        return isEqual && deepEqual(obj[key], compareTo[key]);
+      }, true)
+    : obj === compareTo;
+}
+
+exports.deepEqual = deepEqual;
+exports.getValueByPath = getValueByPath;

package/dist/cjs/observer-f49483e8.js

@@ -0,0 +1,32 @@
+'use strict';
+
+/**
+ *  An Observer is a class that has a listener method that accepts a value of type T
+ *  and calls the listener method with a value of type T
+ */
+class Observer {
+  /**
+   * It accepts a function that accepts a value and returns a boolean, and a function that accepts a value of the type that
+   * the first function accepts
+   *
+   * @typedef T generic type parameter
+   * @param {(input: unknown) => input is T} accept - A function that indicate if the input is acceptable by the observer
+   * @param {(input: T) => void} listener - A function handle the input for the observer if the input is accepted
+   */
+  constructor(accept, listener) {
+    this.accept = accept;
+    this.listener = listener;
+  }
+  /**
+   * If the input is of the type that this handler is interested in, then call the listener function
+   *
+   * @param {unknown} input - unknown
+   */
+  notify(input) {
+    if (this.accept(input)) {
+      this.listener(input);
+    }
+  }
+}
+
+exports.Observer = Observer;

package/dist/cjs/page-resize-observer-slimmer-a8cf1874.js

@@ -0,0 +1,122 @@
+'use strict';
+
+const globalSlimmerRegistry = require('./global-slimmer-registry-b3bce7e0.js');
+const breakpoints = require('./breakpoints-7e2dff90.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;
+  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 `PageResizeObserverSlimmer` class is a TypeScript class that extends `VegaSlimmer` and provides functionality for observing page resize events.
+ *
+ * Note: The slimmer which will extends the `PageResizeObserverSlimmer` should not have same name method `connectedCallbackByResizeSlimmer` , `disconnectedCallbackByResizeSlimmer` and `componentDidLoadByResizeSlimmer`
+ */
+class PageResizeObserverSlimmer extends globalSlimmerRegistry.VegaSlimmer {
+  /**
+   * The constructor function takes a PageResizeObserverEntry object as a parameter.
+   *
+   * @param {PageResizeObserverEntry} observerEntry - The `observerEntry` parameter is an instance of
+   * the `PageResizeObserverEntry` class. It represents an entry in the `PageResizeObserver`'s list of
+   * observed elements. It contains information about the observed element's size and position.
+   */
+  constructor(observerEntry) {
+    super();
+    this.observerEntry = observerEntry;
+  }
+  /**
+   * create resize observer when connectedCallback
+   */
+  reconnectResizeObserver() {
+    if (this.resizeObserver === null) {
+      this.createResizeObserver();
+    }
+  }
+  /**
+   * cancel resize observer when disconnectedCallback
+   */
+  disconnectResizeObserver() {
+    var _a;
+    (_a = this.resizeObserver) === null || _a === void 0 ? void 0 : _a.disconnect();
+    this.resizeObserver = null;
+  }
+  /**
+   * create resize observer when componentDidLoad
+   */
+  connectResizeObserver() {
+    this.createResizeObserver();
+  }
+  /**
+   * The function creates a resize observer that calls a callback function with the current breakpoint whenever the page resize.
+   */
+  createResizeObserver() {
+    var _a;
+    const observerEntry = this.observerEntry;
+    (_a = this.resizeObserver) === null || _a === void 0 ? void 0 : _a.disconnect();
+    const VegaResizeObserver = window['VegaResizeObserver'] || window.ResizeObserver;
+    if (VegaResizeObserver) {
+      this.resizeObserver = new VegaResizeObserver((entries, observer) => {
+        if (observerEntry &&
+          typeof observerEntry.shouldTrigger === 'function' &&
+          !observerEntry.shouldTrigger()) {
+          return;
+        }
+        if (observerEntry && typeof observerEntry.callback === 'function') {
+          /**
+           * The function "handle" calls the callback function of an observer entry with the specified
+           * arguments.
+           */
+          const handle = () => {
+            observerEntry.callback(entries, observer);
+          };
+          observerEntry.isDeferred ? setTimeout(handle) : handle();
+        }
+        else {
+          this.currentBreakpoint = breakpoints.getCurrentBreakpoint();
+        }
+      });
+    }
+    this.observerResizeObserver();
+  }
+  /**
+   * The function `observerResizeObserver` observes the resize of one or multiple HTML elements using the
+   * ResizeObserver API.
+   */
+  observerResizeObserver() {
+    var _a;
+    if (this.resizeObserver) {
+      const resizeObserver = this.resizeObserver;
+      let observers = null;
+      if ((_a = this.observerEntry) === null || _a === void 0 ? void 0 : _a.target) {
+        observers = this.observerEntry.target();
+      }
+      if (Array.isArray(observers)) {
+        observers.forEach((observer) => {
+          resizeObserver.observe(observer);
+        });
+      }
+      else if (observers) {
+        resizeObserver.observe(observers);
+      }
+      else {
+        resizeObserver.observe(document.body);
+      }
+    }
+  }
+}
+__decorate([
+  globalSlimmerRegistry.MapToComponentField({ writable: true, isOptional: true })
+], PageResizeObserverSlimmer.prototype, "currentBreakpoint", void 0);
+__decorate([
+  globalSlimmerRegistry.MapToComponentMethod('connectedCallback')
+], PageResizeObserverSlimmer.prototype, "reconnectResizeObserver", null);
+__decorate([
+  globalSlimmerRegistry.MapToComponentMethod('disconnectedCallback')
+], PageResizeObserverSlimmer.prototype, "disconnectResizeObserver", null);
+__decorate([
+  globalSlimmerRegistry.MapToComponentMethod('componentDidLoad')
+], PageResizeObserverSlimmer.prototype, "connectResizeObserver", null);
+
+exports.PageResizeObserverSlimmer = PageResizeObserverSlimmer;

package/dist/cjs/pixel-98f2a10c.js

@@ -0,0 +1,72 @@
+'use strict';
+
+/* This file is generated by vega-design 2.0.77 */ 
+const Spacing = {
+	"0": 0,
+	"size-4": 4,
+	"size-8": 8,
+	"size-12": 12,
+	"size-16": 16,
+	"size-20": 20,
+	"size-24": 24,
+	"size-32": 32,
+	"size-40": 40,
+	"size-48": 48,
+	"size-64": 64,
+	"size-72": 72,
+	"size-80": 80,
+	"size-112": 112,
+	"size-2": 2
+};
+
+/**
+ * The function parses a string representing a pixel value to a number, or returns the input if it is already a number.
+ *
+ * @param {number | string} input - The input parameter can be either a number or a string. If it is a
+ * string, it should be in the format of a CSS pixel value (e.g. "10px").
+ * @returns {number} returns a number. If the input is already a number, it returns the input as is. If the input is a string, it attempts to extract a number from the
+ * string by removing the 'px' suffix and converting the remaining string to a number. If the string
+ * cannot be converted to a number, it returns 0.
+ */
+function parsePixelStringToNumber(input) {
+  return typeof input === 'number'
+    ? input
+    : input && !isNaN(Number(input.replace('px', '')))
+      ? Number(input.replace('px', ''))
+      : 0;
+}
+/**
+ * The function takes a number or string input and returns a string with 'px' appended if the input is a number.
+ *
+ * @param {number | string} input - The input parameter can be either a number or a string. If it is a
+ * number, the function will convert it to a string and append the 'px' unit to it. If it is already a string, the function will simply return it as is.
+ * @returns {string} returns a string that represents a CSS pixel value. If the input is a number, it concatenates the number with the string 'px'. If the input is already a
+ * string, it returns the input string as is.
+ */
+function parseNumberToPixelString(input) {
+  return typeof input === 'number' ? input + 'px' : input;
+}
+/**
+ * This function takes an input parameter and returns a string.
+ * - If the input is a number, it returns a string with 'px'.
+ * - If the input is a string, it returns the input string as is.
+ * - If the input is a {@link SpacingTokenType}, it returns a parsed value string with 'px'.
+ *
+ * @param {number | string | SpacingTokenType} input - The input parameter can be either a number or a string. If it is a
+ * @returns {string} returns a string that represents a CSS pixel value
+ */
+function parseToPixelString(input) {
+  if (!isNaN(Number(input))) {
+    return `${input}px`;
+  }
+  else if (Object.keys(Spacing).includes(input)) {
+    return `${Spacing[input]}px`;
+  }
+  else {
+    return input;
+  }
+}
+
+exports.parseNumberToPixelString = parseNumberToPixelString;
+exports.parsePixelStringToNumber = parsePixelStringToNumber;
+exports.parseToPixelString = parseToPixelString;

package/dist/cjs/placeholder-cb6d37ad.js

@@ -0,0 +1,27 @@
+'use strict';
+
+/**
+ * The placeholder for mapped slimmer original method
+ *
+ * @param {unknown[]} _args - Placeholder for args
+ * @returns {undefined} Placeholder for returns
+ */
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+function methodPlaceholder(..._args) {
+  return undefined;
+}
+/**
+ * The placeholder for slot
+ *
+ * @param {HTMLElement} slot The slot that will be rendered as a placeholder
+ * @returns {HTMLElement} The slot placeholder element
+ */
+// if the component is rendering the slot, its render method must be placed into
+// the component class otherwise stencil will not identify the slot feature is used during build runtime.
+// ref: https://github.com/ionic-team/stencil/blob/1c8847814203339cc6de42b8c9322f955e333fa4/src/compiler/app-core/app-data.ts#L14
+function slotPlaceholder(slot) {
+  return slot;
+}
+
+exports.methodPlaceholder = methodPlaceholder;
+exports.slotPlaceholder = slotPlaceholder;

package/dist/cjs/regex-c1f70fd4.js

@@ -0,0 +1,15 @@
+'use strict';
+
+const GridRowsRegex = new RegExp(/^([1-9]|1[0-2])(-auto)?$/);
+const GridColumnsRegex = new RegExp(/^([1-9]|1[0-2])(-auto)?$/);
+const VisaRegex = /^4/;
+const MasterCardRegex = /^(5[1-5]|677189)|^(222[1-9]|2[3-6]\d{2}|27[0-1]\d|2720)/;
+const AmexRegex = /^3[47]/;
+const DiscoverRegex = /^(6011|65|64[4-9]|622)/;
+
+exports.AmexRegex = AmexRegex;
+exports.DiscoverRegex = DiscoverRegex;
+exports.GridColumnsRegex = GridColumnsRegex;
+exports.GridRowsRegex = GridRowsRegex;
+exports.MasterCardRegex = MasterCardRegex;
+exports.VisaRegex = VisaRegex;

package/dist/cjs/remote-invocation-registry-32aaf6c2.js

@@ -0,0 +1,64 @@
+'use strict';
+
+const changeManager = require('./change-manager-a297e4d2.js');
+const observer = require('./observer-f49483e8.js');
+
+/**
+ * The `RemoteInvocationRegistry` provides methods for performing remote invocation calls
+ * and registering remote invocation handlers.
+ */
+class RemoteInvocationRegistry {
+  /**
+   * This function performs a remote invocation call and returning the result.
+   *
+   * @param {HTMLElement} subject the dom node subject
+   * @param {unknown[]} args - The `args` parameter of specific method.
+   * @returns {unknown} The result of call `remoteInvocation`.
+   */
+  call(subject, ...args) {
+    let result = null;
+    changeManager.ChangeManager.notify(subject, {
+      args,
+      resultCallback: 
+      /* eslint-disable jsdoc/require-jsdoc */
+      (response) => {
+        result = response;
+      },
+    });
+    return result;
+  }
+  /**
+   * The function registers a remote invocation handler.
+   *
+   * @param {HTMLElement} subject the dom node subject
+   * @param {Function}remoteInvocationHandler - The method that is ultimately called.
+   */
+  register(subject, remoteInvocationHandler) {
+    const observer$1 = new observer.Observer(this.isAcceptableObserver.bind(this), (payload) => {
+      const result = remoteInvocationHandler(...payload.args);
+      payload.resultCallback(result);
+    });
+    changeManager.ChangeManager.register(subject, observer$1);
+  }
+  /**
+   * The function un-registers a remote invocation call handler.
+   *
+   * @param {HTMLElement} subject the dom node subject
+   */
+  unRegister(subject) {
+    changeManager.ChangeManager.clearObserversBySubject(subject);
+  }
+  /**
+   * The function isAcceptableObserver checks if the input matches a specified type T.
+   *
+   * @param {unknown} _input - The `_input` parameter is of type `unknown`, which means it can hold any
+   * value.
+   * @returns {boolean} The `isAcceptableObserver` function is returning `true`.
+   */
+  isAcceptableObserver(_input) {
+    return true;
+  }
+}
+const remoteInvocationRegistry = new RemoteInvocationRegistry();
+
+exports.remoteInvocationRegistry = remoteInvocationRegistry;

package/dist/cjs/required-field-rule-9a57b1a0.js

@@ -0,0 +1,83 @@
+'use strict';
+
+/**
+ * A rule that checks if a string is empty or not
+ *
+ * @implements {FormFieldValidationRule<string>}
+ */
+class RequiredFieldRule {
+  constructor() {
+    /**
+     * A function that checks if the item is a string, number, or boolean.
+     *
+     * @param {unknown} item - The item to be checked.
+     * @returns {boolean} The return value is a boolean that indicates whether the item is string, number or boolean.
+     */
+    this.checkArrayItemType = (item) => typeof item === 'string' || typeof item === 'number' || typeof item === 'boolean';
+  }
+  /**
+   * If the input is a number or a boolean, return true. If the input is a string, return true if the string is not empty
+   *
+   * @param {FormFieldValueType | Array<FormFieldValueType>} input - The input to be evaluated.
+   * @returns {EvaluateResultTranslation} An object with two properties: isValid and message.
+   */
+  evaluate(input) {
+    if (!this.isAcceptedInputType(input)) {
+      throw new Error(`Unexpected type of input: ${typeof input}: ${input}`);
+    }
+    else if (typeof input === 'number' || typeof input === 'boolean') {
+      return {
+        isValid: true,
+        message: '',
+      };
+    }
+    else if (typeof input === 'string' || Array.isArray(input)) {
+      return {
+        isValid: input.length > 0,
+        message: input.length <= 0 ? 'This field is required' : '',
+      };
+    }
+    else {
+      return {
+        isValid: false,
+        message: 'This field is required',
+      };
+    }
+  }
+  /**
+   * If the input is accepted and the status is not disabled and visible, then return true
+   *
+   * @param {unknown} input - The input to be evaluated.
+   * @param {FormFieldStatusMeta} [status] - FormFieldStatusMeta
+   * @returns {boolean} The return value is a boolean that indicates whether the input can be evaluated.
+   */
+  canEvaluate(input, status) {
+    return status
+      ? this.isAcceptedInputType(input) && !status.disabled && status.visible
+      : this.isAcceptedInputType(input);
+  }
+  /**
+   * If the field is not disabled, visible, and has been touched or modified, then show the error
+   *
+   * @param {FormFieldStatusMeta} status - FormFieldStatusMeta
+   * @returns {boolean} A boolean value.
+   */
+  shouldShowError(status) {
+    return !status.disabled && status.visible && (status.touched || status.modified);
+  }
+  /**
+   * If the input is a string, number, boolean, or null, return true, otherwise return false.
+   *
+   * @param {unknown} input - The input value to be validated.
+   * @returns {boolean} a boolean value.
+   */
+  isAcceptedInputType(input) {
+    return (typeof input === 'string' ||
+      typeof input === 'number' ||
+      typeof input === 'boolean' ||
+      (Array.isArray(input) && input.every(this.checkArrayItemType)) ||
+      input === null);
+  }
+}
+
+exports.RequiredFieldRule = RequiredFieldRule;