@evance/evance-ui 1.0.38 → 1.0.40

package/dist/esm/chunks/helpers-2xLRXvqh.mjs

@@ -0,0 +1,227 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+/*! Evance UI v1.0.40 | MIT License */
+var _a, _b;
+import { reactive, computed, watchEffect, toRefs, unref } from "vue";
+import { g as getCurrentComponent } from "./components-DXtB006g.mjs";
+import { h as isArray, f as isFunction, j as isObjectNotArray } from "./is-functions-mbSk0wXG.mjs";
+const _Browser = class _Browser {
+  /**
+   * ## Supports Touch
+   * Added into a static getter method to avoid issues during development when switching between emulators.
+   */
+  static get supportsTouch() {
+    return this.hasWindow && ("ontouchstart" in window || window.navigator.maxTouchPoints > 0);
+  }
+};
+__publicField(_Browser, "hasWindow", typeof window !== "undefined");
+__publicField(_Browser, "supportsIntersection", _Browser.hasWindow && "IntersectionObserver" in window);
+__publicField(_Browser, "supportsFocusVisible", _Browser.hasWindow && ((_b = (_a = window.CSS) == null ? void 0 : _a.supports) == null ? void 0 : _b.call(_a, "selector(:focus-visible)")));
+let Browser = _Browser;
+let currentId = 0;
+let assignedIds = /* @__PURE__ */ new WeakMap();
+function getNextId() {
+  const component = getCurrentComponent("getNextId()");
+  if (assignedIds.has(component)) {
+    return assignedIds.get(component);
+  }
+  const id = ++currentId;
+  assignedIds.set(component, id);
+  return id;
+}
+getNextId.reset = () => {
+  currentId = 0;
+  assignedIds = /* @__PURE__ */ new WeakMap();
+};
+function getPropertyValue(subject, property, fallback) {
+  if (property === true) {
+    return subject === void 0 ? fallback : subject;
+  }
+  if (property == null || typeof property === "boolean") {
+    return fallback;
+  }
+  if (subject !== Object(subject)) {
+    if (typeof property !== "function") {
+      return fallback;
+    }
+    const value2 = property(subject, fallback);
+    return typeof value2 === "undefined" ? fallback : value2;
+  }
+  if (typeof property === "string") {
+    return getPropertyValueByPath(subject, property, fallback);
+  }
+  if (Array.isArray(property)) {
+    return getNestedPropertyValue(subject, property, fallback);
+  }
+  if (!isFunction(property)) {
+    return fallback;
+  }
+  const value = property(subject, fallback);
+  return typeof value === "undefined" ? fallback : value;
+}
+function getPropertyValueByPath(subject, objectPath, fallback) {
+  if (subject == null || !objectPath) {
+    return fallback;
+  }
+  const propertyKeys = objectPathToPropertyKeys(objectPath);
+  return getNestedPropertyValue(subject, propertyKeys, fallback);
+}
+function setPropertyValueByPath(subject, objectPath, value) {
+  if (subject == null || !objectPath) {
+    return;
+  }
+  const propertyKeys = objectPathToPropertyKeys(objectPath);
+  let obj = subject;
+  while (propertyKeys.length > 1) {
+    obj = obj[propertyKeys.shift()];
+  }
+  obj[propertyKeys[0]] = value;
+}
+function getNestedPropertyValue(subject, propertyKeys, fallback) {
+  let lastValue = subject;
+  for (const property of propertyKeys) {
+    if (lastValue === void 0) {
+      break;
+    }
+    lastValue = lastValue[property];
+  }
+  return lastValue === void 0 ? fallback : lastValue;
+}
+function objectPathToPropertyKeys(path) {
+  return path.split(/[.\[\]\/]+/).filter(Boolean);
+}
+function refElement(obj) {
+  return obj && "$el" in obj ? obj.$el : obj;
+}
+function splitObject(subject, paths, exclude) {
+  const matching = /* @__PURE__ */ Object.create(null);
+  const remaining = /* @__PURE__ */ Object.create(null);
+  for (const key in subject) {
+    if (paths.some(
+      (path) => path instanceof RegExp ? path.test(key) : path === key
+    ) && !(exclude == null ? void 0 : exclude.some((path) => path === key))) {
+      matching[key] = subject[key];
+    } else {
+      remaining[key] = subject[key];
+    }
+  }
+  return [matching, remaining];
+}
+function splitInputAttrs(attrs) {
+  return splitObject(attrs, ["class", "style", "id", /^data-/]);
+}
+function clamp(value, min = 0, max = 1) {
+  return Math.max(min, Math.min(max, value));
+}
+function destructComputed(getter) {
+  const refs = reactive({});
+  const base = computed(getter);
+  watchEffect(
+    () => {
+      for (const key in base.value) {
+        refs[key] = base.value[key];
+      }
+    },
+    { flush: "sync" }
+  );
+  return toRefs(refs);
+}
+function getPropertyDescriptor(obj, key) {
+  let currentObj = obj;
+  while (currentObj) {
+    const descriptor = Reflect.getOwnPropertyDescriptor(currentObj, key);
+    if (descriptor) {
+      return descriptor;
+    }
+    currentObj = Object.getPrototypeOf(currentObj);
+  }
+  return void 0;
+}
+function filterComponentProps(component, props) {
+  return splitObject(props, Object.keys(component.props), [
+    "class",
+    "style"
+  ])[0];
+}
+function wrapInArray(value) {
+  return value == null ? [] : isArray(value) ? value : [value];
+}
+function mergeDeep(source = {}, target = {}, arrayFn) {
+  const out = {};
+  for (const key in source) {
+    out[key] = source[key];
+  }
+  for (const key in target) {
+    const sourceProperty = source[key];
+    const targetProperty = target[key];
+    if (isObjectNotArray(sourceProperty) && isObjectNotArray(targetProperty)) {
+      out[key] = mergeDeep(sourceProperty, targetProperty, arrayFn);
+      continue;
+    }
+    if (isArray(sourceProperty) && isArray(targetProperty) && arrayFn) {
+      out[key] = arrayFn(sourceProperty, targetProperty);
+      continue;
+    }
+    out[key] = targetProperty;
+  }
+  return out;
+}
+function createRange(length, start = 0) {
+  return Array.from({ length }, (v, k) => start + k);
+}
+function omit(obj, exclude) {
+  const clone = { ...obj };
+  exclude.forEach((prop) => delete clone[prop]);
+  return clone;
+}
+function matchesSelector(el, selector) {
+  const supportsSelector = Browser.hasWindow && typeof CSS !== "undefined" && typeof CSS.supports !== "undefined" && CSS.supports(`selector(${selector})`);
+  if (!supportsSelector) {
+    return null;
+  }
+  try {
+    return !!el && el.matches(selector);
+  } catch (err) {
+    return null;
+  }
+}
+function keys(o) {
+  return Object.keys(o);
+}
+function debounce(fn, delay) {
+  let timeoutId = 0;
+  const wrap = (...args) => {
+    clearTimeout(timeoutId);
+    timeoutId = setTimeout(() => fn(...args), unref(delay));
+  };
+  wrap.clear = () => {
+    clearTimeout(timeoutId);
+  };
+  wrap.immediate = fn;
+  return wrap;
+}
+export {
+  Browser as B,
+  getPropertyValue as a,
+  clamp as b,
+  createRange as c,
+  debounce as d,
+  setPropertyValueByPath as e,
+  filterComponentProps as f,
+  getNextId as g,
+  getPropertyValueByPath as h,
+  destructComputed as i,
+  matchesSelector as j,
+  keys as k,
+  getNestedPropertyValue as l,
+  mergeDeep as m,
+  objectPathToPropertyKeys as n,
+  omit as o,
+  splitObject as p,
+  getPropertyDescriptor as q,
+  refElement as r,
+  splitInputAttrs as s,
+  wrapInArray as w
+};
+//# sourceMappingURL=helpers-2xLRXvqh.mjs.map

package/dist/esm/chunks/helpers-2xLRXvqh.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers-2xLRXvqh.mjs","sources":["../../../src/util/browser.ts","../../../src/util/helpers.ts"],"sourcesContent":["/**\n * # Browser\n */\nexport class Browser {\n    public static readonly hasWindow: boolean = typeof window !== \"undefined\";\n\n    public static readonly supportsIntersection: boolean =\n        this.hasWindow && \"IntersectionObserver\" in window;\n\n    /**\n     * ## Supports Touch\n     * Added into a static getter method to avoid issues during development when switching between emulators.\n     */\n    public static get supportsTouch(): boolean {\n        return (\n            this.hasWindow &&\n            (\"ontouchstart\" in window || window.navigator.maxTouchPoints > 0)\n        );\n    }\n\n    public static readonly supportsFocusVisible: boolean =\n        this.hasWindow && window.CSS?.supports?.(\"selector(:focus-visible)\");\n}\n","import {\r\n    ComponentInternalInstance,\r\n    ComponentOptions,\r\n    ComponentPublicInstance,\r\n    computed,\r\n    ComputedGetter, MaybeRef,\r\n    reactive,\r\n    toRefs,\r\n    ToRefs, unref,\r\n    watchEffect,\r\n} from \"vue\";\r\nimport {\r\n    Browser,\r\n    getCurrentComponent,\r\n    isArray,\r\n    isFunction,\r\n    isObjectNotArray,\r\n} from \"../util\";\r\n\r\n/**\r\n * # Get Next ID\r\n */\r\nlet currentId: number = 0;\r\nlet assignedIds = new WeakMap<ComponentInternalInstance, number>();\r\nexport function getNextId(): number {\r\n    const component = getCurrentComponent(\"getNextId()\");\r\n    if (assignedIds.has(component)) {\r\n        return assignedIds.get(component)!;\r\n    }\r\n    const id = ++currentId;\r\n    assignedIds.set(component, id);\r\n    return id;\r\n}\r\ngetNextId.reset = () => {\r\n    currentId = 0;\r\n    assignedIds = new WeakMap();\r\n};\r\n\r\n/**\r\n * # Getter Property Key\r\n *\r\n * Defines where to look for Property information within getter functions.\r\n *\r\n * For example: an object might have a `title` property.\r\n * So a property key may represent either an array index, or an object property.\r\n *\r\n * - `boolean`, `null`, `undefined` - Ignored\r\n * - `string` - Property name, or use Object path notation.\r\n * - `array` of strings or numbers represent nested lookup - each array element represents a key in the hierarchy\r\n * - A callback function accepting `item` and `fallback` arguments.\r\n */\r\nexport type GetterPropertyKey<T = Record<string, any>> =\r\n    | boolean\r\n    | null\r\n    | undefined\r\n    | string\r\n    | (string | number)[]\r\n    | ((item: T, fallback?: any) => any);\r\n\r\n/**\r\n * # Get Property\r\n *\r\n * A getter function, which gets a property from the `subject`, which may be\r\n * any kind of object.\r\n *\r\n */\r\nexport function getPropertyValue(\r\n    subject: any,\r\n    property: GetterPropertyKey,\r\n    fallback?: any,\r\n): any {\r\n    if (property === true) {\r\n        return subject === undefined ? fallback : subject;\r\n    }\r\n    if (property == null || typeof property === \"boolean\") {\r\n        return fallback;\r\n    }\r\n    if (subject !== Object(subject)) {\r\n        if (typeof property !== \"function\") {\r\n            return fallback;\r\n        }\r\n        const value = property(subject, fallback);\r\n        return typeof value === \"undefined\" ? fallback : value;\r\n    }\r\n    if (typeof property === \"string\") {\r\n        return getPropertyValueByPath(subject, property, fallback);\r\n    }\r\n    if (Array.isArray(property)) {\r\n        return getNestedPropertyValue(subject, property, fallback);\r\n    }\r\n    if (!isFunction(property)) {\r\n        return fallback;\r\n    }\r\n    const value = property(subject, fallback);\r\n    return typeof value === \"undefined\" ? fallback : value;\r\n}\r\n\r\n/**\r\n * # Get Property from Path\r\n *\r\n * This is a rough copy of Evance's `EvObjectPathGetter` functionality.\r\n *\r\n * @param subject\r\n * @param objectPath\r\n * @param fallback\r\n */\r\nexport function getPropertyValueByPath(\r\n    subject: any,\r\n    objectPath: string,\r\n    fallback?: any,\r\n) {\r\n    if (subject == null || !objectPath) {\r\n        return fallback;\r\n    }\r\n    const propertyKeys = objectPathToPropertyKeys(objectPath);\r\n    return getNestedPropertyValue(subject, propertyKeys, fallback);\r\n}\r\n\r\n/**\r\n *\r\n * @param subject\r\n * @param objectPath\r\n * @param value\r\n */\r\nexport function setPropertyValueByPath(\r\n    subject: any,\r\n    objectPath: string,\r\n    value: any,\r\n) {\r\n    if (subject == null || !objectPath) {\r\n        return;\r\n    }\r\n    const propertyKeys = objectPathToPropertyKeys(objectPath);\r\n    let obj = subject;\r\n    while (propertyKeys.length > 1) {\r\n        obj = obj[propertyKeys.shift()];\r\n    }\r\n    obj[propertyKeys[0]] = value;\r\n}\r\n\r\n/**\r\n * # Get Nested Property Value\r\n *\r\n * @param subject\r\n * @param propertyKeys\r\n * @param fallback\r\n */\r\nexport function getNestedPropertyValue(\r\n    subject: any,\r\n    propertyKeys: PropertyKey[],\r\n    fallback?: any,\r\n): any {\r\n    let lastValue = subject;\r\n    for (const property of propertyKeys) {\r\n        if (lastValue === undefined) {\r\n            break;\r\n        }\r\n        lastValue = lastValue[property];\r\n    }\r\n    return lastValue === undefined ? fallback : lastValue;\r\n}\r\n\r\n/**\r\n * # Object Path To Array\r\n *\r\n * This is a rough copy of Evance's `EvObjectPath` functionality.\r\n *\r\n * @param path\r\n */\r\nexport function objectPathToPropertyKeys(path: string): PropertyKey[] {\r\n    return path.split(/[.\\[\\]\\/]+/).filter(Boolean);\r\n}\r\n\r\n/**\r\n * # Ref Element\r\n * @param obj\r\n */\r\nexport function refElement<T extends object | undefined>(\r\n    obj: T,\r\n): Exclude<T, ComponentPublicInstance> | HTMLElement {\r\n    return obj && \"$el\" in obj\r\n        ? (obj.$el as HTMLElement)\r\n        : (obj as HTMLElement);\r\n}\r\n\r\n/**\r\n * # Split Object\r\n *\r\n * Split an object into two using an Array of keys or RegExp to test keys against.\r\n *\r\n * This results an array containing an object containing only matching keys,\r\n * and an object containing the remaining keys.\r\n *\r\n * @param subject\r\n * @param paths\r\n * @param exclude\r\n */\r\nexport function splitObject<\r\n    Subject extends object,\r\n    SubjectKey extends Extract<keyof Subject, string>,\r\n    Exclusions extends Extract<keyof Subject, string>,\r\n>(\r\n    subject: Subject,\r\n    paths: (SubjectKey | RegExp)[],\r\n    exclude?: Exclusions[],\r\n): [matched: Partial<Subject>, unmatched: Partial<Subject>] {\r\n    const matching = Object.create(null);\r\n    const remaining = Object.create(null);\r\n    for (const key in subject) {\r\n        if (\r\n            paths.some((path) =>\r\n                path instanceof RegExp ? path.test(key) : path === key,\r\n            ) &&\r\n            !exclude?.some((path) => path === key)\r\n        ) {\r\n            matching[key] = subject[key];\r\n        } else {\r\n            remaining[key] = subject[key];\r\n        }\r\n    }\r\n    return [matching, remaining];\r\n}\r\n\r\n/**\r\n * ## Split Input Attrs\r\n *\r\n * Filter/split an attributes objects into two objects:\r\n * 1. Attributes not intended for an input field.\r\n * 2. Attributes for an input field.\r\n *\r\n * @param attrs\r\n */\r\nexport function splitInputAttrs(attrs: Record<string, unknown>) {\r\n    return splitObject(attrs, [\"class\", \"style\", \"id\", /^data-/]);\r\n}\r\n\r\n/**\r\n * # Clamp\r\n *\r\n * @param value\r\n * @param min\r\n * @param max\r\n */\r\nexport function clamp(value: number, min = 0, max = 1) {\r\n    return Math.max(min, Math.min(max, value));\r\n}\r\n\r\n// Only allow a single return type\r\ntype NotAUnion<T> = [T] extends [infer U] ? _NotAUnion<U, U> : never;\r\ntype _NotAUnion<T, U> = U extends any\r\n    ? [T] extends [U]\r\n        ? unknown\r\n        : never\r\n    : never;\r\n\r\n/**\r\n * # Destruct Computed\r\n *\r\n * Convert a computed ref to a record of refs.\r\n * The getter function must always return an object with the same keys.\r\n */\r\nexport function destructComputed<T extends object>(\r\n    getter: ComputedGetter<T & NotAUnion<T>>,\r\n): ToRefs<T>;\r\nexport function destructComputed<T extends object>(getter: ComputedGetter<T>) {\r\n    const refs = reactive({}) as T;\r\n    const base = computed(getter);\r\n    watchEffect(\r\n        () => {\r\n            for (const key in base.value) {\r\n                refs[key] = base.value[key];\r\n            }\r\n        },\r\n        { flush: \"sync\" },\r\n    );\r\n    return toRefs(refs);\r\n}\r\n\r\n/**\r\n * # Union To Intersection\r\n *\r\n * Intersection `I` of all types in the union `U` - transform a union of object types into an intersection of those types.\r\n * This can be helpful when you want to combine multiple types into a single type, where all properties from each type\r\n * become part of the resulting type.\r\n */\r\nexport type UnionToIntersection<U> = (\r\n    U extends any ? (k: U) => void : never\r\n) extends (k: infer I) => void\r\n    ? I\r\n    : never;\r\n\r\n/**\r\n * # Get Descriptor\r\n *\r\n * Returns the closest property descriptor for an object.\r\n *\r\n * @param obj\r\n * @param key\r\n */\r\nexport function getPropertyDescriptor(obj: any, key: PropertyKey) {\r\n    let currentObj = obj;\r\n    while (currentObj) {\r\n        const descriptor = Reflect.getOwnPropertyDescriptor(currentObj, key);\r\n        if (descriptor) {\r\n            return descriptor;\r\n        }\r\n        currentObj = Object.getPrototypeOf(currentObj);\r\n    }\r\n    return undefined;\r\n}\r\n\r\n/**\r\n * # Filter Component Props\r\n *\r\n * Extracts the component's props from a props record.\r\n *\r\n * Excludes `class` and `style`.\r\n *\r\n * @param component\r\n * @param props\r\n */\r\nexport function filterComponentProps(\r\n    component: ComponentOptions<any>,\r\n    props: Record<string, any>,\r\n) {\r\n    return splitObject(props, Object.keys(component.props), [\r\n        \"class\",\r\n        \"style\",\r\n    ])[0];\r\n}\r\n\r\n/**\r\n * # If Any\r\n */\r\ntype IfAny<T, Y, N> = 0 extends 1 & T ? Y : N;\r\n\r\n/**\r\n * # Wrap In Array\r\n * @param value\r\n */\r\nexport function wrapInArray<T>(\r\n    value: T | null | undefined,\r\n): T extends readonly any[] ? IfAny<T, T[], T> : NonNullable<T>[] {\r\n    return value == null ? [] : isArray(value) ? (value as any) : [value];\r\n}\r\n\r\nexport function mergeDeep(\r\n    source: Record<string, any> = {},\r\n    target: Record<string, any> = {},\r\n    arrayFn?: (a: unknown[], b: unknown[]) => unknown[],\r\n) {\r\n    const out: Record<string, any> = {};\r\n\r\n    for (const key in source) {\r\n        out[key] = source[key];\r\n    }\r\n\r\n    for (const key in target) {\r\n        const sourceProperty = source[key];\r\n        const targetProperty = target[key];\r\n\r\n        // Only continue deep merging if\r\n        // both properties are objects\r\n        if (\r\n            isObjectNotArray(sourceProperty) &&\r\n            isObjectNotArray(targetProperty)\r\n        ) {\r\n            out[key] = mergeDeep(sourceProperty, targetProperty, arrayFn);\r\n            continue;\r\n        }\r\n\r\n        if (isArray(sourceProperty) && isArray(targetProperty) && arrayFn) {\r\n            out[key] = arrayFn(sourceProperty, targetProperty);\r\n            continue;\r\n        }\r\n\r\n        out[key] = targetProperty;\r\n    }\r\n\r\n    return out;\r\n}\r\n\r\n/**\r\n * # Create Range\r\n *\r\n * @param length\r\n * @param start\r\n */\r\nexport function createRange(length: number, start = 0): number[] {\r\n    return Array.from({ length }, (v, k) => start + k);\r\n}\r\n\r\n/**\r\n * # Omit\r\n *\r\n * Clones an object, whilst omitting excluded properties.\r\n *\r\n * @param obj\r\n * @param exclude\r\n */\r\nexport function omit<T extends object, U extends Extract<keyof T, string>>(\r\n    obj: T,\r\n    exclude: U[],\r\n): Omit<T, U> {\r\n    const clone = { ...obj };\r\n\r\n    exclude.forEach((prop) => delete clone[prop]);\r\n\r\n    return clone;\r\n}\r\n\r\n/**\r\n * # matchesSelector\r\n * Returns `null` if the CSS selector is not supported, or can't be checked.\r\n * @param el\r\n * @param selector\r\n */\r\nexport function matchesSelector(\r\n    el: Element | undefined,\r\n    selector: string,\r\n): boolean | null {\r\n    const supportsSelector =\r\n        Browser.hasWindow &&\r\n        typeof CSS !== \"undefined\" &&\r\n        typeof CSS.supports !== \"undefined\" &&\r\n        CSS.supports(`selector(${selector})`);\r\n\r\n    if (!supportsSelector) {\r\n        return null;\r\n    }\r\n\r\n    try {\r\n        return !!el && el.matches(selector);\r\n    } catch (err) {\r\n        return null;\r\n    }\r\n}\r\n\r\nexport function keys<O extends {}>(o: O) {\r\n    return Object.keys(o) as (keyof O)[];\r\n}\r\n\r\ntype DebouncedFunction<T extends (...args: any[]) => any> = {\r\n    (...args: Parameters<T>): void;\r\n    clear: () => void;\r\n    immediate: T;\r\n};\r\n\r\n/**\r\n * ## debounce\r\n *\r\n * @param fn The function to debounce\r\n * @param delay The debounce delay (either a number or a ref of a number)\r\n * @returns A debounced version of the function with `clear` and `immediate` methods\r\n */\r\nexport function debounce<T extends (...args: any[]) => any>(\r\n    fn: T,\r\n    delay: MaybeRef<number>,\r\n): DebouncedFunction<T> {\r\n    let timeoutId = 0 as any;\r\n    const wrap = (...args: any[]) => {\r\n        clearTimeout(timeoutId);\r\n        timeoutId = setTimeout(() => fn(...args), unref(delay));\r\n    };\r\n    wrap.clear = () => {\r\n        clearTimeout(timeoutId);\r\n    };\r\n    wrap.immediate = fn;\r\n    return wrap;\r\n}\r\n"],"names":["value"],"mappings":"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"}

package/dist/esm/chunks/icons-DwKL1IBC.mjs

@@ -0,0 +1,29 @@
+/*! Evance UI v1.0.40 | MIT License */
+import { W as WarningIcon, N as NoteIcon, C as CheckCircleIcon, I as InfoIcon, D as DangerIcon, H as HelpIcon } from "./WarningIcon-DDrz95YY.mjs";
+import { A as Appearance } from "./appearance-CEdpAlZF.mjs";
+const IconProp = [
+  String,
+  Function,
+  Object,
+  Array
+];
+function appearanceIcon(appearance) {
+  switch (appearance) {
+    case Appearance.danger:
+      return DangerIcon;
+    case Appearance.information:
+      return InfoIcon;
+    case Appearance.success:
+      return CheckCircleIcon;
+    case Appearance.notice:
+      return NoteIcon;
+    case Appearance.warning:
+      return WarningIcon;
+  }
+  return HelpIcon;
+}
+export {
+  IconProp as I,
+  appearanceIcon as a
+};
+//# sourceMappingURL=icons-DwKL1IBC.mjs.map

package/dist/esm/chunks/icons-DwKL1IBC.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"icons-DwKL1IBC.mjs","sources":["../../../src/composables/icons.ts"],"sourcesContent":["import { ComponentPublicInstance, FunctionalComponent, PropType } from \"vue\";\nimport { Appearance } from \"@/util\";\nimport {\n    CheckCircleIcon,\n    DangerIcon,\n    HelpIcon,\n    InfoIcon,\n    NoteIcon,\n    WarningIcon,\n} from \"@/icons\";\n\nexport type JsxComponent<Props = any> =\n    | { new (): ComponentPublicInstance<Props> }\n    | FunctionalComponent<Props>;\n\nexport type IconValue =\n    | string\n    | (string | [path: string, opacity: number])[]\n    | JsxComponent;\n\nexport const IconProp = [\n    String,\n    Function,\n    Object,\n    Array,\n] as PropType<IconValue>;\n\n/**\n * # appearanceIcon\n *\n * Returns the default icon associated with an appearance value.\n *\n * @param appearance\n */\nexport function appearanceIcon(appearance?: string) {\n    switch (appearance) {\n        case Appearance.danger:\n            return DangerIcon;\n        case Appearance.information:\n            return InfoIcon;\n        case Appearance.success:\n            return CheckCircleIcon;\n        case Appearance.notice:\n            return NoteIcon;\n        case Appearance.warning:\n            return WarningIcon;\n    }\n    return HelpIcon;\n}\n"],"names":[],"mappings":";;;AAoBO,MAAM,WAAW;AAAA,EACpB;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACJ;AASO,SAAS,eAAe,YAAqB;AAChD,UAAQ,YAAY;AAAA,IAChB,KAAK,WAAW;AACL,aAAA;AAAA,IACX,KAAK,WAAW;AACL,aAAA;AAAA,IACX,KAAK,WAAW;AACL,aAAA;AAAA,IACX,KAAK,WAAW;AACL,aAAA;AAAA,IACX,KAAK,WAAW;AACL,aAAA;AAAA,EAAA;AAER,SAAA;AACX;"}

package/dist/esm/chunks/is-functions-mbSk0wXG.mjs

@@ -0,0 +1,116 @@
+/*! Evance UI v1.0.40 | MIT License */
+function is(a, b) {
+  return Object.is(a, b);
+}
+function isArray(value) {
+  return Array.isArray(value);
+}
+function isBoolean(value) {
+  return typeof value === "boolean";
+}
+function isCssVariable(value) {
+  if (!isString(value)) {
+    return false;
+  }
+  return /^--[\w-]+$/.test(value);
+}
+function isDate(value) {
+  return value instanceof Date;
+}
+function isDateEqual(a, b) {
+  return a.getTime() === b.getTime();
+}
+function isDeepEqual(a, b) {
+  if (a === b) {
+    return true;
+  }
+  if (typeof a !== typeof b) {
+    return false;
+  }
+  if (a == null || b == null) {
+    return false;
+  }
+  if (isDate(a) && isDate(b) && !isDateEqual(a, b)) {
+    return false;
+  }
+  if (isArray(a) !== isArray(b)) {
+    return false;
+  }
+  if (a !== Object(a) || b !== Object(b)) {
+    return false;
+  }
+  const keysInA = Object.keys(a);
+  const keysInB = Object.keys(b);
+  if (keysInA.length !== keysInB.length) {
+    return false;
+  }
+  return keysInA.every((key) => isDeepEqual(a[key], b[key]));
+}
+function isElement(el) {
+  return !!el && el instanceof Element && el.nodeType === Node.ELEMENT_NODE;
+}
+function isEmpty(value) {
+  return value === null || value === void 0 || typeof value === "string" && value.trim() === "";
+}
+function isEqualNaN(value) {
+  return value !== value;
+}
+function isFunction(value) {
+  return typeof value === "function";
+}
+function isNumber(value) {
+  return typeof value === "number";
+}
+function isObject(value) {
+  return typeof value === "object";
+}
+function isObjectNotArray(value) {
+  return value !== null && isObject(value) && !isArray(value);
+}
+const isOnPattern = /^on[^a-z]/;
+const isOn = (key) => isOnPattern.test(key);
+function isPrimitive(value) {
+  return Object(value) !== value;
+}
+function isShadowRoot(value) {
+  return typeof ShadowRoot !== "undefined" && value instanceof ShadowRoot;
+}
+function isString(value) {
+  if (typeof value === "string") {
+    return true;
+  }
+  if (typeof value !== "object") {
+    return false;
+  }
+  try {
+    String.prototype.valueOf.call(value);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+function isTypeOf(value, accept) {
+  return accept.includes(typeof value);
+}
+export {
+  isObject as a,
+  isBoolean as b,
+  isDeepEqual as c,
+  isEmpty as d,
+  isOn as e,
+  isFunction as f,
+  isElement as g,
+  isArray as h,
+  isString as i,
+  isObjectNotArray as j,
+  isCssVariable as k,
+  isNumber as l,
+  isShadowRoot as m,
+  is as n,
+  isDate as o,
+  isDateEqual as p,
+  isEqualNaN as q,
+  isPrimitive as r,
+  isTypeOf as s
+};
+//# sourceMappingURL=is-functions-mbSk0wXG.mjs.map

package/dist/esm/chunks/is-functions-mbSk0wXG.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-functions-mbSk0wXG.mjs","sources":["../../../src/util/is-functions.ts"],"sourcesContent":["/**\n * # Is (equal)\n * I had written a polyfill for this, but since we're only interested in modern browsers\n * let's reduce code and simply return the result from Object.is();\n * @param a\n * @param b\n */\nexport function is(a?: any, b?: any): boolean {\n    return Object.is(a, b);\n}\n\n/**\n * # Is Array?\n * @param value\n */\nexport function isArray(value: unknown): boolean {\n    return Array.isArray(value);\n}\n\n/**\n * # Is Boolean?\n * @param value\n */\nexport function isBoolean(value: unknown): value is boolean {\n    return typeof value === \"boolean\";\n}\n\n/**\n * # Is CSS Variable\n * @param value\n */\nexport function isCssVariable(value: unknown): boolean {\n    if (!isString(value)) {\n        return false;\n    }\n    return /^--[\\w-]+$/.test(value as string);\n}\n\n/**\n * # Is Date?\n * @param value\n */\nexport function isDate(value: unknown): value is Date {\n    return value instanceof Date;\n}\n\n/**\n * # Is Date Equal\n *\n * Evaluates whether one date equals another date.\n *\n * @param a\n * @param b\n */\nexport function isDateEqual(a: Date, b: Date): boolean {\n    return a.getTime() === b.getTime();\n}\n\n/**\n * # Is Deep Equal?\n *\n * I could have used the `deep-equal` npm package, but decided to keep things as light-weight\n * as possible and this suits our needs for now:\n *\n * @link https://www.npmjs.com/package/deep-equal\n *\n * @param a\n * @param b\n */\nexport function isDeepEqual(a: any, b: any): boolean {\n    if (a === b) {\n        return true;\n    }\n    // Check types\n    if (typeof a !== typeof b) {\n        return false;\n    }\n    if (a == null || b == null) {\n        return false;\n    }\n\n    // Check dates\n    if (isDate(a) && isDate(b) && !isDateEqual(a, b)) {\n        return false;\n    }\n    // Check array\n    if (isArray(a) !== isArray(b)) {\n        return false;\n    }\n\n    if (a !== Object(a) || b !== Object(b)) {\n        return false;\n    }\n\n    const keysInA = Object.keys(a);\n    const keysInB = Object.keys(b);\n    if (keysInA.length !== keysInB.length) {\n        return false;\n    }\n    return keysInA.every((key) => isDeepEqual(a[key], b[key]));\n}\n\nexport function isElement(el: unknown): el is Element {\n    return !!el && el instanceof Element && el.nodeType === Node.ELEMENT_NODE;\n}\n\n/**\n * # Is Empty\n * @param value\n */\nexport function isEmpty(value: any): boolean {\n    return (\n        value === null ||\n        value === undefined ||\n        (typeof value === \"string\" && value.trim() === \"\")\n    );\n}\n\n/**\n * # Is Equal NaN\n *\n * Check if a value is NaN - the only value in JavaScript that is not equal to itself.\n *\n * @param value\n */\nexport function isEqualNaN(value: unknown): boolean {\n    return value !== value;\n}\n\n/**\n * # Is Function?\n * @param value\n */\nexport function isFunction(value: unknown): value is Function {\n    return typeof value === \"function\";\n}\n\n/**\n * # Is Number\n * @param value\n */\nexport function isNumber(value: unknown): value is number {\n    return typeof value === \"number\";\n}\n\n/**\n * # Is Object?\n * @param value\n */\nexport function isObject(value: unknown): value is object {\n    return typeof value === \"object\";\n}\n\n/**\n * # Is Object Not Array\n * @param value\n */\nexport function isObjectNotArray(value: any): boolean {\n    return value !== null && isObject(value) && !isArray(value);\n}\n\nconst isOnPattern = /^on[^a-z]/;\nexport const isOn = (key: string) => isOnPattern.test(key);\n\n/**\n *\n * @param value\n */\nexport function isPrimitive(\n    value: unknown,\n): value is string | number | boolean {\n    return Object(value) !== value;\n}\n\n/**\n * # Is ShadowRoot\n * @param value\n */\nexport function isShadowRoot(value: unknown): value is ShadowRoot {\n    return typeof ShadowRoot !== \"undefined\" && value instanceof ShadowRoot;\n}\n\n/**\n * # Is String?\n * @param value\n */\nexport function isString(value: unknown): value is string {\n    if (typeof value === \"string\") {\n        return true;\n    }\n    if (typeof value !== \"object\") {\n        return false;\n    }\n    try {\n        String.prototype.valueOf.call(value);\n        return true;\n    } catch (e) {\n        return false;\n    }\n}\n\nexport function isTypeOf(value: unknown, accept: string[]): boolean {\n    return accept.includes(typeof value);\n}\n"],"names":[],"mappings":";AAOgB,SAAA,GAAG,GAAS,GAAkB;AACnC,SAAA,OAAO,GAAG,GAAG,CAAC;AACzB;AAMO,SAAS,QAAQ,OAAyB;AACtC,SAAA,MAAM,QAAQ,KAAK;AAC9B;AAMO,SAAS,UAAU,OAAkC;AACxD,SAAO,OAAO,UAAU;AAC5B;AAMO,SAAS,cAAc,OAAyB;AAC/C,MAAA,CAAC,SAAS,KAAK,GAAG;AACX,WAAA;AAAA,EAAA;AAEJ,SAAA,aAAa,KAAK,KAAe;AAC5C;AAMO,SAAS,OAAO,OAA+B;AAClD,SAAO,iBAAiB;AAC5B;AAUgB,SAAA,YAAY,GAAS,GAAkB;AACnD,SAAO,EAAE,cAAc,EAAE,QAAQ;AACrC;AAagB,SAAA,YAAY,GAAQ,GAAiB;AACjD,MAAI,MAAM,GAAG;AACF,WAAA;AAAA,EAAA;AAGP,MAAA,OAAO,MAAM,OAAO,GAAG;AAChB,WAAA;AAAA,EAAA;AAEP,MAAA,KAAK,QAAQ,KAAK,MAAM;AACjB,WAAA;AAAA,EAAA;AAIP,MAAA,OAAO,CAAC,KAAK,OAAO,CAAC,KAAK,CAAC,YAAY,GAAG,CAAC,GAAG;AACvC,WAAA;AAAA,EAAA;AAGX,MAAI,QAAQ,CAAC,MAAM,QAAQ,CAAC,GAAG;AACpB,WAAA;AAAA,EAAA;AAGX,MAAI,MAAM,OAAO,CAAC,KAAK,MAAM,OAAO,CAAC,GAAG;AAC7B,WAAA;AAAA,EAAA;AAGL,QAAA,UAAU,OAAO,KAAK,CAAC;AACvB,QAAA,UAAU,OAAO,KAAK,CAAC;AACzB,MAAA,QAAQ,WAAW,QAAQ,QAAQ;AAC5B,WAAA;AAAA,EAAA;AAEJ,SAAA,QAAQ,MAAM,CAAC,QAAQ,YAAY,EAAE,GAAG,GAAG,EAAE,GAAG,CAAC,CAAC;AAC7D;AAEO,SAAS,UAAU,IAA4B;AAClD,SAAO,CAAC,CAAC,MAAM,cAAc,WAAW,GAAG,aAAa,KAAK;AACjE;AAMO,SAAS,QAAQ,OAAqB;AAErC,SAAA,UAAU,QACV,UAAU,UACT,OAAO,UAAU,YAAY,MAAM,KAAA,MAAW;AAEvD;AASO,SAAS,WAAW,OAAyB;AAChD,SAAO,UAAU;AACrB;AAMO,SAAS,WAAW,OAAmC;AAC1D,SAAO,OAAO,UAAU;AAC5B;AAMO,SAAS,SAAS,OAAiC;AACtD,SAAO,OAAO,UAAU;AAC5B;AAMO,SAAS,SAAS,OAAiC;AACtD,SAAO,OAAO,UAAU;AAC5B;AAMO,SAAS,iBAAiB,OAAqB;AAClD,SAAO,UAAU,QAAQ,SAAS,KAAK,KAAK,CAAC,QAAQ,KAAK;AAC9D;AAEA,MAAM,cAAc;AACb,MAAM,OAAO,CAAC,QAAgB,YAAY,KAAK,GAAG;AAMlD,SAAS,YACZ,OACkC;AAC3B,SAAA,OAAO,KAAK,MAAM;AAC7B;AAMO,SAAS,aAAa,OAAqC;AACvD,SAAA,OAAO,eAAe,eAAe,iBAAiB;AACjE;AAMO,SAAS,SAAS,OAAiC;AAClD,MAAA,OAAO,UAAU,UAAU;AACpB,WAAA;AAAA,EAAA;AAEP,MAAA,OAAO,UAAU,UAAU;AACpB,WAAA;AAAA,EAAA;AAEP,MAAA;AACO,WAAA,UAAU,QAAQ,KAAK,KAAK;AAC5B,WAAA;AAAA,WACF,GAAG;AACD,WAAA;AAAA,EAAA;AAEf;AAEgB,SAAA,SAAS,OAAgB,QAA2B;AACzD,SAAA,OAAO,SAAS,OAAO,KAAK;AACvC;"}