@voicenter-team/voicenter-ui-plus 2.0.12 → 3.0.0

package/library/utils/excelParser/validations.mjs

@@ -0,0 +1,100 @@
+function isNullOrUndefined(value) {
+  return value === null || value === void 0;
+}
+const req = (value) => {
+  if (isNullOrUndefined(value) || isEmptyArray(value)) {
+    return false;
+  }
+  return !!String(value).trim().length;
+};
+function isEmptyArray(arr) {
+  return Array.isArray(arr) && arr.length === 0;
+}
+const len = (value) => {
+  if (Array.isArray(value)) return value.length;
+  if (typeof value === "object" && value !== null) {
+    return Object.keys(value).length;
+  }
+  return String(value).length;
+};
+const validate = (rule, value, opt) => {
+  return rule(value, opt);
+};
+const validateColumn = (options, val) => {
+  const resultValid = {
+    valid: true,
+    errors: []
+  };
+  const _keys = Object.keys(options).filter((k) => k in rules);
+  _keys.forEach((k) => {
+    const _option = options[k];
+    const _rule = rules[k];
+    if (_option && _rule) {
+      const isValid = validate(_rule, val, _option);
+      if (!isValid.valid) {
+        resultValid.valid = false;
+        resultValid.errors.push(isValid);
+      }
+    }
+  });
+  return resultValid;
+};
+const rules = {
+  required: (value) => {
+    const result = {
+      valid: false,
+      type: "required"
+    };
+    result.valid = req(value);
+    return result;
+  },
+  numeric: (value) => {
+    const result = {
+      valid: false,
+      type: "numeric"
+    };
+    const mask = /^[0-9]*$/;
+    result.valid = !req(value) || mask.test(String(value));
+    return result;
+  },
+  minLength: (value, length) => {
+    const result = {
+      valid: false,
+      type: "minLength"
+    };
+    const lengthValue = length || 0;
+    if (typeof lengthValue === "boolean") {
+      result.valid = lengthValue;
+    } else {
+      result.valid = !req(value) || len(value) >= lengthValue;
+    }
+    return result;
+  },
+  maxLength: (value, length) => {
+    const result = {
+      valid: false,
+      type: "maxLength"
+    };
+    const lengthValue = length || 0;
+    if (typeof lengthValue === "boolean") {
+      result.valid = lengthValue;
+    } else {
+      result.valid = !req(value) || len(value) <= lengthValue;
+    }
+    return result;
+  },
+  alphaNum: (value) => {
+    const result = {
+      valid: false,
+      type: "alphaNum"
+    };
+    const mask = /^[a-zA-Z0-9]*$/;
+    result.valid = !req(value) || mask.test(String(value));
+    return result;
+  }
+};
+export {
+  rules,
+  validate,
+  validateColumn
+};

package/library/utils/globalSingleton.mjs

@@ -0,0 +1,12 @@
+const NS = "voicenter-ui-plus";
+function globalSymbol(name) {
+  return Symbol.for(`${NS}:${name}`);
+}
+function globalSingleton(key, init) {
+  const store = globalThis.__voicenterUiPlusSingletons ?? (globalThis.__voicenterUiPlusSingletons = {});
+  return store[key] ?? (store[key] = init());
+}
+export {
+  globalSingleton,
+  globalSymbol
+};

package/library/utils/helpers.mjs

@@ -0,0 +1,64 @@
+import { get } from "lodash-es";
+function convertToUnit(str, unit = "px") {
+  if (str == null || str === "") {
+    return void 0;
+  } else if (isNaN(+str)) {
+    return String(str);
+  } else {
+    return `${Number(str)}${unit}`;
+  }
+}
+function hasElProperty(value) {
+  return "$el" in value;
+}
+function checkRef(ref) {
+  if (ref instanceof HTMLElement) {
+    return ref;
+  }
+  if (hasElProperty(ref)) {
+    const refEl = ref.$el;
+    if (ref.constructor.name === "VueComponent" && refEl instanceof HTMLElement) {
+      return refEl;
+    }
+  }
+  return null;
+}
+const getRefElement = function(ref) {
+  if (!ref) {
+    return null;
+  }
+  if (Array.isArray(ref) && ref.length) {
+    return checkRef(ref[0]);
+  }
+  return checkRef(ref);
+};
+function isFunction(obj) {
+  return typeof obj === "function";
+}
+function resolveFieldData(obj, field, defaultValue = null) {
+  if (obj && typeof obj === "object" && Object.keys(obj).length && field) {
+    if (isFunction(field)) {
+      return field(obj);
+    } else if (typeof field === "string") {
+      return get(obj, field, defaultValue);
+    }
+  }
+  return defaultValue || null;
+}
+const getFileSize = (bytes, decimals = 2) => {
+  if (bytes === 0) return "0 Bytes";
+  const k = 1024;
+  const dm = decimals < 0 ? 0 : decimals;
+  const sizes = ["Bytes", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return [
+    parseFloat((bytes / Math.pow(k, i)).toFixed(dm)),
+    sizes[i]
+  ];
+};
+export {
+  convertToUnit,
+  getFileSize,
+  getRefElement,
+  resolveFieldData
+};

package/library/utils/jsonSchema/helpers.mjs

@@ -0,0 +1,93 @@
+import { keys, isEqual, xor } from "lodash-es";
+import { isEqual as isEqual2, keys as keys2, merge, xor as xor2 } from "lodash-es";
+import { FORMAT_REGEXPS, isFormat, types } from "./jsonSchemaHelpers.mjs";
+const helpers = {
+  stringFormats: keys(FORMAT_REGEXPS),
+  isFormat,
+  typeNames: [
+    "integer",
+    "number",
+    // make sure number is after integer (for proper type detection)
+    "string",
+    "array",
+    "object",
+    "boolean",
+    "null",
+    "date"
+  ],
+  getType(val) {
+    return helpers.typeNames.find((typeName) => types[typeName](val));
+  },
+  /**
+   * Tries to find the least common schema from two supplied JSON schemas. If it is unable to find
+   * such a schema, it returns null. Incompatibility in structure/types leads to returning null,
+   * except when the difference is only integer/number. Than the 'number' is used instead 'int'.
+   * Types/Structure incompatibility in array items only leads to schema that doesn't specify
+   * items structure/type.
+   * @param {object} schema1 - JSON schema
+   * @param {object} schema2 - JSON schema
+   * @returns {object|null}
+   */
+  mergeSchemaObjs(schema1, schema2) {
+    const schema1Keys = keys(schema1);
+    const schema2Keys = keys(schema2);
+    if (!isEqual(schema1Keys, schema2Keys)) {
+      if (schema1.type === "array" && schema2.type === "array") {
+        if (isEqual(xor(schema1Keys, schema2Keys), ["items"])) {
+          const schemaWithoutItems = schema1Keys.length > schema2Keys.length ? schema2 : schema1;
+          const schemaWithItems = schema1Keys.length > schema2Keys.length ? schema1 : schema2;
+          const isSame = keys(schemaWithoutItems).reduce((acc, current) => isEqual(schemaWithoutItems[current], schemaWithItems[current]) && acc, true);
+          if (isSame) {
+            return schemaWithoutItems;
+          }
+        }
+      }
+      if (schema1.type !== "object" || schema2.type !== "object") {
+        return null;
+      }
+    }
+    const retObj = {};
+    for (let i = 0, { length } = schema1Keys; i < length; i++) {
+      const key = schema1Keys[i];
+      if (helpers.getType(schema1[key]) === "object") {
+        const x = helpers.mergeSchemaObjs(schema1[key], schema2[key]);
+        if (!x) {
+          if (schema1.type === "object" || schema2.type === "object") {
+            return { type: "object" };
+          }
+          if (key !== "items" || schema1.type !== "array" || schema2.type !== "array") {
+            return null;
+          }
+        } else {
+          retObj[key] = x;
+        }
+      } else {
+        if (key === "type") {
+          if (schema1[key] !== schema2[key]) {
+            if (schema1[key] === "integer" && schema2[key] === "number" || schema1[key] === "number" && schema2[key] === "integer") {
+              retObj[key] = "number";
+            } else {
+              return null;
+            }
+          } else {
+            retObj[key] = schema1[key];
+          }
+        } else {
+          if (!isEqual(schema1[key], schema2[key])) {
+            return null;
+          }
+          retObj[key] = schema1[key];
+        }
+      }
+    }
+    return retObj;
+  }
+};
+export {
+  helpers as default,
+  helpers,
+  isEqual2 as isEqual,
+  keys2 as keys,
+  merge,
+  xor2 as xor
+};

package/library/utils/jsonSchema/index.mjs

@@ -0,0 +1,208 @@
+import helpers from "./helpers.mjs";
+import { merge, isEqual } from "lodash-es";
+const defaultOptions = {
+  required: false,
+  postProcessFnc: null,
+  strings: {
+    detectFormat: true,
+    preProcessFnc: null
+  },
+  arrays: {
+    mode: "all"
+  },
+  objects: {
+    preProcessFnc: null,
+    postProcessFnc: null,
+    additionalProperties: true
+  }
+};
+const skipReverseFind = ["hostname", "host-name", "alpha", "alphanumeric", "regex", "regexp", "pattern"];
+const filteredFormats = helpers.stringFormats.filter((item) => skipReverseFind.indexOf(item) < 0);
+function getCommonTypeFromArrayOfTypes(arrOfTypes) {
+  let lastVal;
+  for (let i = 0, { length } = arrOfTypes; i < length; i++) {
+    let currentType = arrOfTypes[i];
+    if (i > 0) {
+      if (currentType === "integer" && lastVal === "number") {
+        currentType = "number";
+      } else if (currentType === "number" && lastVal === "integer") {
+        lastVal = "number";
+      }
+      if (lastVal !== currentType) return null;
+    }
+    lastVal = currentType;
+  }
+  return lastVal;
+}
+function getCommonArrayItemsType(arr) {
+  return getCommonTypeFromArrayOfTypes(arr.map((item) => helpers.getType(item)));
+}
+class ToJsonSchema {
+  constructor(options) {
+    this.options = merge({}, defaultOptions, options);
+    this.getObjectSchemaDefault = this.getObjectSchemaDefault.bind(this);
+    this.getStringSchemaDefault = this.getStringSchemaDefault.bind(this);
+    this.objectPostProcessDefault = this.objectPostProcessDefault.bind(this);
+    this.commmonPostProcessDefault = this.commmonPostProcessDefault.bind(this);
+    this.objectPostProcessDefault = this.objectPostProcessDefault.bind(this);
+  }
+  /**
+   * Tries to find the least common schema that would validate all items in the array. More details
+   * helpers.mergeSchemaObjs description
+   * @param {array} arr
+   * @returns {object|null}
+   */
+  getCommonArrayItemSchema(arr) {
+    const schemas = arr.map((item) => this.getSchema(item));
+    return schemas.reduce((acc, current) => helpers.mergeSchemaObjs(acc, current), schemas.pop());
+  }
+  getObjectSchemaDefault(obj) {
+    const schema = { type: "object" };
+    const objKeys = Object.keys(obj);
+    if (objKeys.length > 0) {
+      schema.properties = objKeys.reduce((acc, propertyName) => {
+        acc[propertyName] = this.getSchema(obj[propertyName]);
+        return acc;
+      }, {});
+    }
+    return schema;
+  }
+  getObjectSchema(obj) {
+    if (this.options.objects.preProcessFnc) {
+      return this.options.objects.preProcessFnc(obj, this.getObjectSchemaDefault);
+    }
+    return this.getObjectSchemaDefault(obj);
+  }
+  getArraySchemaMerging(arr) {
+    const schema = { type: "array" };
+    const commonType = getCommonArrayItemsType(arr);
+    if (commonType) {
+      schema.items = { type: commonType };
+      if (commonType !== "integer" && commonType !== "number") {
+        const itemSchema = this.getCommonArrayItemSchema(arr);
+        if (itemSchema) {
+          schema.items = itemSchema;
+        }
+      } else if (this.options.required) {
+        schema.items.required = true;
+      }
+    }
+    return schema;
+  }
+  getArraySchemaNoMerging(arr) {
+    const schema = { type: "array" };
+    if (arr.length > 0) {
+      schema.items = this.getSchema(arr[0]);
+    }
+    return schema;
+  }
+  getArraySchemaTuple(arr) {
+    const schema = { type: "array" };
+    if (arr.length > 0) {
+      schema.items = arr.map((item) => this.getSchema(item));
+    }
+    return schema;
+  }
+  getArraySchemaUniform(arr) {
+    const schema = this.getArraySchemaNoMerging(arr);
+    if (arr.length > 1) {
+      for (let i = 1; i < arr.length; i++) {
+        if (!isEqual(schema.items, this.getSchema(arr[i]))) {
+          throw new Error("Invalid schema, incompatible array items");
+        }
+      }
+    }
+    return schema;
+  }
+  getArraySchema(arr) {
+    if (arr.length === 0) {
+      return { type: "array" };
+    }
+    switch (this.options.arrays.mode) {
+      case "all":
+        return this.getArraySchemaMerging(arr);
+      case "first":
+        return this.getArraySchemaNoMerging(arr);
+      case "uniform":
+        return this.getArraySchemaUniform(arr);
+      case "tuple":
+        return this.getArraySchemaTuple(arr);
+      default:
+        throw new Error(`Unknown array mode option '${this.options.arrays.mode}'`);
+    }
+  }
+  getStringSchemaDefault(value) {
+    const schema = { type: "string" };
+    if (!this.options.strings.detectFormat) {
+      return schema;
+    }
+    const index = filteredFormats.findIndex((item) => helpers.isFormat(value, item));
+    if (index >= 0) {
+      schema.format = filteredFormats[index];
+    }
+    return schema;
+  }
+  getStringSchema(value) {
+    if (this.options.strings.preProcessFnc) {
+      return this.options.strings.preProcessFnc(value, this.getStringSchemaDefault);
+    }
+    return this.getStringSchemaDefault(value);
+  }
+  commmonPostProcessDefault(type, schema) {
+    if (this.options.required) {
+      return merge({}, schema, { required: true });
+    }
+    return schema;
+  }
+  objectPostProcessDefault(schema, obj) {
+    if (this.options.objects.additionalProperties === false && Object.getOwnPropertyNames(obj).length > 0) {
+      return merge({}, schema, { additionalProperties: false });
+    }
+    return schema;
+  }
+  /**
+   * Gets JSON schema for provided value
+   * @param value
+   * @returns {object}
+   */
+  getSchema(value) {
+    const type = helpers.getType(value);
+    if (!type) {
+      throw new Error("Type of value couldn't be determined");
+    }
+    let schema;
+    switch (type) {
+      case "object":
+        schema = this.getObjectSchema(value);
+        break;
+      case "array":
+        schema = this.getArraySchema(value);
+        break;
+      case "string":
+        schema = this.getStringSchema(value);
+        break;
+      default:
+        schema = { type };
+    }
+    if (this.options.postProcessFnc) {
+      schema = this.options.postProcessFnc(type, schema, value, this.commmonPostProcessDefault);
+    } else {
+      schema = this.commmonPostProcessDefault(type, schema, value);
+    }
+    if (type === "object") {
+      if (this.options.objects.postProcessFnc) {
+        schema = this.options.objects.postProcessFnc(schema, value, this.objectPostProcessDefault);
+      } else {
+        schema = this.objectPostProcessDefault(schema, value);
+      }
+    }
+    return schema;
+  }
+}
+function toJsonSchema(value, options) {
+  const tjs = new ToJsonSchema(options);
+  return tjs.getSchema(value);
+}
+export {
+  toJsonSchema
+};

package/library/utils/jsonSchema/jsonSchemaHelpers.mjs

@@ -0,0 +1,79 @@
+const types = {
+  string: function testString(instance) {
+    return typeof instance === "string";
+  },
+  number: function testNumber(instance) {
+    return typeof instance === "number" && isFinite(instance);
+  },
+  integer: function testInteger(instance) {
+    return typeof instance === "number" && instance % 1 === 0;
+  },
+  boolean: function testBoolean(instance) {
+    return typeof instance === "boolean";
+  },
+  array: function testArray(instance) {
+    return instance instanceof Array;
+  },
+  null: function testNull(instance) {
+    return instance === null;
+  },
+  date: function testDate(instance) {
+    return instance instanceof Date;
+  },
+  any: (
+    /* istanbul ignore next: not using this but keeping it here for sake of completeness */
+    function testAny() {
+      return true;
+    }
+  ),
+  object: function testObject(instance) {
+    return instance && typeof instance === "object" && !(instance instanceof Array) && !(instance instanceof Date);
+  }
+};
+const FORMAT_REGEXPS = {
+  "date-time": /^\d{4}-(?:0[0-9]{1}|1[0-2]{1})-(3[01]|0[1-9]|[12][0-9])[tT ](2[0-4]|[01][0-9]):([0-5][0-9]):(60|[0-5][0-9])(\.\d+)?([zZ]|[+-]([0-5][0-9]):(60|[0-5][0-9]))$/,
+  date: /^\d{4}-(?:0[0-9]{1}|1[0-2]{1})-(3[01]|0[1-9]|[12][0-9])$/,
+  time: /^(2[0-4]|[01][0-9]):([0-5][0-9]):(60|[0-5][0-9])$/,
+  email: /^(?:[\w!#$%&'*+-/=?^`{|}~]+\.)*[\w!#$%&'*+-/=?^`{|}~]+@(?:(?:(?:[a-zA-Z0-9](?:[a-zA-Z0-9-](?!\.)){0,61}[a-zA-Z0-9]?\.)+[a-zA-Z0-9](?:[a-zA-Z0-9-](?!$)){0,61}[a-zA-Z0-9]?)|(?:\[(?:(?:[01]?\d{1,2}|2[0-4]\d|25[0-5])\.){3}(?:[01]?\d{1,2}|2[0-4]\d|25[0-5])\]))$/,
+  "ip-address": /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/,
+  ipv6: /^\s*((([0-9A-Fa-f]{1,4}:){7}([0-9A-Fa-f]{1,4}|:))|(([0-9A-Fa-f]{1,4}:){6}(:[0-9A-Fa-f]{1,4}|((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9A-Fa-f]{1,4}:){5}(((:[0-9A-Fa-f]{1,4}){1,2})|:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9A-Fa-f]{1,4}:){4}(((:[0-9A-Fa-f]{1,4}){1,3})|((:[0-9A-Fa-f]{1,4})?:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){3}(((:[0-9A-Fa-f]{1,4}){1,4})|((:[0-9A-Fa-f]{1,4}){0,2}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){2}(((:[0-9A-Fa-f]{1,4}){1,5})|((:[0-9A-Fa-f]{1,4}){0,3}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){1}(((:[0-9A-Fa-f]{1,4}){1,6})|((:[0-9A-Fa-f]{1,4}){0,4}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(:(((:[0-9A-Fa-f]{1,4}){1,7})|((:[0-9A-Fa-f]{1,4}){0,5}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:)))(%.+)?\s*$/,
+  uri: /^[a-zA-Z][a-zA-Z0-9+-.]*:[^\s]*$/,
+  color: /^(#?([0-9A-Fa-f]{3}){1,2}\b|aqua|black|blue|fuchsia|gray|green|lime|maroon|navy|olive|orange|purple|red|silver|teal|white|yellow|(rgb\(\s*\b([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\b\s*,\s*\b([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\b\s*,\s*\b([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\b\s*\))|(rgb\(\s*(\d?\d%|100%)+\s*,\s*(\d?\d%|100%)+\s*,\s*(\d?\d%|100%)+\s*\)))$/,
+  // hostname regex from: http://stackoverflow.com/a/1420225/5628
+  hostname: /^(?=.{1,255}$)[0-9A-Za-z](?:(?:[0-9A-Za-z]|-){0,61}[0-9A-Za-z])?(?:\.[0-9A-Za-z](?:(?:[0-9A-Za-z]|-){0,61}[0-9A-Za-z])?)*\.?$/,
+  "host-name": /^(?=.{1,255}$)[0-9A-Za-z](?:(?:[0-9A-Za-z]|-){0,61}[0-9A-Za-z])?(?:\.[0-9A-Za-z](?:(?:[0-9A-Za-z]|-){0,61}[0-9A-Za-z])?)*\.?$/,
+  alpha: /^[a-zA-Z]+$/,
+  alphanumeric: /^[a-zA-Z0-9]+$/,
+  "utc-millisec": (input) => typeof input === "string" && parseFloat(input) === parseInt(input, 10) && !isNaN(input),
+  // eslint-disable-line no-restricted-globals
+  regex(input) {
+    let result = true;
+    try {
+      new RegExp(input);
+    } catch (e) {
+      result = false;
+    }
+    return result;
+  },
+  style: /\s*(.+?):\s*([^;]+);?/g,
+  phone: /^\+(?:[0-9] ?){6,14}[0-9]$/
+};
+FORMAT_REGEXPS.regexp = FORMAT_REGEXPS.regex;
+FORMAT_REGEXPS.pattern = FORMAT_REGEXPS.regex;
+FORMAT_REGEXPS.ipv4 = FORMAT_REGEXPS["ip-address"];
+const isFormat = function isFormat2(input, format) {
+  if (typeof input === "string" && FORMAT_REGEXPS[format] !== void 0) {
+    if (FORMAT_REGEXPS[format] instanceof RegExp) {
+      return FORMAT_REGEXPS[format].test(input);
+    }
+    if (typeof FORMAT_REGEXPS[format] === "function") {
+      return FORMAT_REGEXPS[format](input);
+    }
+  }
+  return true;
+};
+export {
+  FORMAT_REGEXPS,
+  isFormat,
+  types
+};

package/library/utils/lucideIcon.mjs

@@ -0,0 +1,60 @@
+import { isVueComponent } from "../types/icons.types.mjs";
+const lucideIconCache = /* @__PURE__ */ new Map();
+function isLegacyIconClass(icon) {
+  return icon.trim().startsWith("vc-");
+}
+function toLucideKebabName(name) {
+  return name.trim().replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/([A-Z])([A-Z][a-z])/g, "$1-$2").toLowerCase();
+}
+function toLucidePascalName(name) {
+  return toLucideKebabName(name).split("-").filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+function getCachedLucideIcon(name) {
+  const kebabName = toLucideKebabName(name);
+  if (!kebabName) return null;
+  return lucideIconCache.get(kebabName) ?? null;
+}
+function cacheLucideIcon(kebabName, component) {
+  lucideIconCache.set(kebabName, component);
+  return component;
+}
+async function importLucideIconModule(kebabName) {
+  try {
+    const module = await import(`@lucide/vue/dist/esm/icons/${kebabName}.mjs`);
+    const component = module.default;
+    return isVueComponent(component) ? component : null;
+  } catch {
+    return null;
+  }
+}
+async function importLucideIconNamedExport(name) {
+  try {
+    const module = await import("@lucide/vue");
+    const component = module[toLucidePascalName(name)];
+    return isVueComponent(component) ? component : null;
+  } catch {
+    return null;
+  }
+}
+async function resolveLucideIcon(name) {
+  const cached = getCachedLucideIcon(name);
+  if (cached) return cached;
+  const kebabName = toLucideKebabName(name);
+  if (!kebabName) return null;
+  const fromModule = await importLucideIconModule(kebabName);
+  if (fromModule) {
+    return cacheLucideIcon(kebabName, fromModule);
+  }
+  const fromNamedExport = await importLucideIconNamedExport(name);
+  if (fromNamedExport) {
+    return cacheLucideIcon(kebabName, fromNamedExport);
+  }
+  return null;
+}
+export {
+  getCachedLucideIcon,
+  isLegacyIconClass,
+  resolveLucideIcon,
+  toLucideKebabName,
+  toLucidePascalName
+};

package/library/utils/makeDataTestAttributeValue.mjs

@@ -0,0 +1,6 @@
+function makeDataTestAttributeValue(attribute, value) {
+  return `${attribute}-${value}`;
+}
+export {
+  makeDataTestAttributeValue as default
+};

package/library/utils/mime-types.mjs

@@ -0,0 +1,24 @@
+function getMimeTypeFromBuffer(file, fallback) {
+  const byteArray = new Uint8Array(file).subarray(0, 4);
+  let header = "";
+  for (let i = 0; i < byteArray.length; i++) {
+    header += byteArray[i].toString(16);
+  }
+  switch (header) {
+    case "89504e47":
+      return "image/png";
+    case "47494638":
+      return "image/gif";
+    case "ffd8ffe0":
+    case "ffd8ffe1":
+    case "ffd8ffe2":
+    case "ffd8ffe3":
+    case "ffd8ffe8":
+      return "image/jpeg";
+    default:
+      return fallback;
+  }
+}
+export {
+  getMimeTypeFromBuffer
+};