@ulu/frontend-vue 0.2.0-beta.2 → 0.2.0-beta.4

package/dist/components/elements/UluButtonVerbose.vue.js

@@ -0,0 +1,118 @@
+import { RouterLink as _ } from "vue-router";
+import g from "./UluIcon.vue.js";
+import { useModifiers as h } from "../../composables/useModifiers.js";
+import { resolveComponent as y, createBlock as l, openBlock as i, resolveDynamicComponent as u, mergeProps as v, withCtx as c, createCommentVNode as s, createElementBlock as S, renderSlot as d, createTextVNode as f, toDisplayString as m } from "vue";
+import B from "../../_virtual/_plugin-vue_export-helper.js";
+const k = {
+  name: "UluButtonVerbose",
+  components: {
+    UluIcon: g
+  },
+  props: {
+    /**
+     * The title of the button. Can also be passed via slot.
+     */
+    title: String,
+    /**
+     * Optional element to use for title
+     */
+    titleElement: {
+      type: String,
+      default: "strong"
+    },
+    /**
+     * The body text of the button. Can also be passed via slot.
+     */
+    body: String,
+    /**
+     * Icon prop, if used will set the icon for the button, will use UluIcon (which uses font-awesome icons conditionally)
+     */
+    icon: [String, Array],
+    /**
+     * If set will use router-link for button component and pass to prop
+     */
+    to: [String, Object],
+    /**
+     * Sets the button to a link with this href
+     */
+    href: String,
+    /**
+     * Set a value for target attribute when button is a link
+     */
+    target: String,
+    /**
+     * Sets the download attribute on the link (passing string [filename] will populate the download attribute, true will just include it as boolean attribute)
+     */
+    download: [Boolean, String],
+    /**
+     * Preset to set inline style
+     */
+    inline: Boolean,
+    /**
+     * Preset to set full-width style
+     */
+    fullWidth: Boolean,
+    /**
+     * Modifiers (to add any modifier classes based on base class [ie. 'tertiary'])
+     */
+    modifiers: [String, Array]
+  },
+  setup(e) {
+    const { resolvedModifiers: o } = h({ props: e, baseClass: "button-verbose" });
+    return { resolvedModifiers: o };
+  },
+  computed: {
+    element() {
+      return this.to ? _ : this.href ? "a" : "button";
+    },
+    attrs() {
+      const { to: e, href: o, download: t, target: n } = this, r = e ? { to: e } : o ? { href: o } : {};
+      return o && (n && (r.target = n), t && (r.download = typeof t == "string" ? t : !0)), r;
+    }
+  }
+}, w = {
+  key: 1,
+  class: "button-verbose__body"
+};
+function C(e, o, t, n, r, a) {
+  const b = y("UluIcon");
+  return i(), l(u(a.element), v({
+    class: ["button-verbose", [
+      {
+        "button-verbose--inline": t.inline,
+        "button-verbose--full-width": t.fullWidth
+      },
+      n.resolvedModifiers
+    ]]
+  }, a.attrs), {
+    default: c(() => [
+      e.$slots.title || t.title ? (i(), l(u(t.titleElement), {
+        key: 0,
+        class: "button-verbose__title"
+      }, {
+        default: c(() => [
+          d(e.$slots, "title", {}, () => [
+            f(m(t.title), 1)
+          ])
+        ]),
+        _: 3
+      })) : s("", !0),
+      e.$slots.default || t.body ? (i(), S("span", w, [
+        d(e.$slots, "default", {}, () => [
+          f(m(t.body), 1)
+        ])
+      ])) : s("", !0),
+      t.icon ? (i(), l(b, {
+        key: 2,
+        icon: t.icon,
+        class: "button-verbose__icon",
+        "aria-hidden": "true"
+      }, null, 8, ["icon"])) : s("", !0)
+    ]),
+    _: 3
+  }, 16, ["class"]);
+}
+const M = /* @__PURE__ */ B(k, [["render", C]]);
+export {
+  M as default
+};

package/dist/{types/components → components}/elements/UluCallout.vue.d.ts

@@ -1,4 +1,4 @@
-declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
     /**
      * Add full height utility class
      */
@@ -10,7 +10,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     modifiers: (StringConstructor | ArrayConstructor)[];
 }>, {
     resolvedModifiers: any;
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
     /**
      * Add full height utility class
      */
@@ -22,6 +22,6 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     modifiers: (StringConstructor | ArrayConstructor)[];
 }>> & Readonly<{}>, {
     fullHeight: boolean;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
 export default _default;
 //# sourceMappingURL=UluCallout.vue.d.ts.map

package/dist/components/elements/UluCallout.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UluCallout.vue.d.ts","sourceRoot":"","sources":["../../../lib/components/elements/UluCallout.vue"],"names":[],"mappings":"AAQA;;IAmCM;;OAEG;;IAEH;;;OAGG;;;;;IAPH;;OAEG;;IAEH;;;OAGG"}

package/dist/components/elements/UluCallout.vue.js

@@ -0,0 +1,32 @@
+import { useModifiers as t } from "../../composables/useModifiers.js";
+import { createElementBlock as s, openBlock as a, normalizeClass as i, renderSlot as n } from "vue";
+import f from "../../_virtual/_plugin-vue_export-helper.js";
+const u = {
+  name: "UluCallout",
+  props: {
+    /**
+     * Add full height utility class
+     */
+    fullHeight: Boolean,
+    /**
+     * Class modifiers (ie. 'transparent', 'secondary', etc)
+     * - Can be String or Array of Strings
+     */
+    modifiers: [String, Array]
+  },
+  setup(e) {
+    const { resolvedModifiers: o } = t({ props: e, baseClass: "callout" });
+    return { resolvedModifiers: o };
+  }
+};
+function c(e, o, l, r, d, m) {
+  return a(), s("div", {
+    class: i(["callout", [r.resolvedModifiers, { "full-height": l.fullHeight }]])
+  }, [
+    n(e.$slots, "default")
+  ], 2);
+}
+const g = /* @__PURE__ */ f(u, [["render", c]]);
+export {
+  g as default
+};

package/dist/components/elements/UluCard.vue.d.ts

@@ -0,0 +1,69 @@
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & (new () => {
+    $slots: S;
+});
+declare const __VLS_component: import('vue').DefineComponent<{}, {
+    $emit: (event: "proxy-click", ...args: any[]) => void;
+    classes: Record<string, any>;
+    titleElement: string;
+    cardElement: string;
+    proxyClick: boolean;
+    proxyClickOptions: Record<string, any>;
+    imageIcon: boolean;
+    horizontal: boolean;
+    horizontalCenter: boolean;
+    overlay: boolean;
+    title?: string | undefined;
+    modifiers?: string | unknown[] | undefined;
+    target?: string | undefined;
+    href?: string | undefined;
+    to?: string | Record<string, any> | undefined;
+    titleTo?: string | Record<string, any> | undefined;
+    titleHref?: string | undefined;
+    titleTarget?: string | undefined;
+    imageSrc?: string | undefined;
+    imageAlt?: string | undefined;
+    $props: {
+        readonly classes?: Record<string, any> | undefined;
+        readonly titleElement?: string | undefined;
+        readonly cardElement?: string | undefined;
+        readonly proxyClick?: boolean | undefined;
+        readonly proxyClickOptions?: Record<string, any> | undefined;
+        readonly imageIcon?: boolean | undefined;
+        readonly horizontal?: boolean | undefined;
+        readonly horizontalCenter?: boolean | undefined;
+        readonly overlay?: boolean | undefined;
+        readonly title?: string | undefined;
+        readonly modifiers?: string | unknown[] | undefined;
+        readonly target?: string | undefined;
+        readonly href?: string | undefined;
+        readonly to?: string | Record<string, any> | undefined;
+        readonly titleTo?: string | Record<string, any> | undefined;
+        readonly titleHref?: string | undefined;
+        readonly titleTarget?: string | undefined;
+        readonly imageSrc?: string | undefined;
+        readonly imageAlt?: string | undefined;
+    };
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    cardRoot: unknown;
+    link: HTMLAnchorElement;
+}, any>;
+type __VLS_TemplateResult = {
+    attrs: Partial<{}>;
+    slots: {
+        title?(_: {}): any;
+        title?(_: {}): any;
+        title?(_: {}): any;
+        body?(_: {}): any;
+        aside?(_: {}): any;
+        image?(_: {}): any;
+        footer?(_: {}): any;
+    };
+    refs: {
+        cardRoot: unknown;
+        link: HTMLAnchorElement;
+    };
+    rootEl: any;
+};
+//# sourceMappingURL=UluCard.vue.d.ts.map

package/dist/components/elements/UluCard.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UluCard.vue.d.ts","sourceRoot":"","sources":["../../../lib/components/elements/UluCard.vue"],"names":[],"mappings":"AA+EA;wBAkpBqB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;;6BAEtE,CAAC,EAAE,CAAC;;;AAbjC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAUG"}

package/dist/components/elements/UluCard.vue.js

@@ -0,0 +1,229 @@
+import { useSlots as N, ref as f, computed as r, createBlock as k, openBlock as a, resolveDynamicComponent as B, normalizeStyle as R, normalizeClass as h, unref as n, withCtx as S, createElementVNode as C, createElementBlock as m, createCommentVNode as y, renderSlot as i, createTextVNode as x, toDisplayString as b } from "vue";
+import { RouterLink as P } from "vue-router";
+import { useModifiers as V } from "../../composables/useModifiers.js";
+import { refToElement as I } from "../../utils/dom.js";
+const q = { class: "card__body" }, L = { class: "card__main" }, F = ["href", "target"], G = {
+  key: 0,
+  class: "card__aside"
+}, J = ["src", "alt"], K = {
+  key: 1,
+  class: "card__footer"
+}, Z = {
+  __name: "UluCard",
+  props: {
+    /**
+     * Specify card element, unless to or href are used which will use 'a' or 'router-link'
+     * - Other than changing to more appropriate element (ie 'li' if in list for example), this can 
+     *   be used to set the card to a button to attach your own click handlers to
+     */
+    cardElement: {
+      type: String,
+      default: "article"
+    },
+    /**
+     * Text for title if not using slot
+     */
+    title: String,
+    /**
+     * Element to use for title
+     */
+    titleElement: {
+      type: String,
+      default: "h3"
+    },
+    /**
+     * Title will be router link
+     */
+    titleTo: [String, Object],
+    /**
+     * Will make title a link to href
+     */
+    titleHref: String,
+    /**
+     * When using href this will set title link's target attribute
+     */
+    titleTarget: String,
+    /**
+     * If set the entire card will be router link
+     * - Do not us in combination with titleTo or titleHref
+     */
+    to: [String, Object],
+    /**
+     * If set the entire card will be a link to href
+     * - Do not us in combination with titleTo or titleHref
+     */
+    href: String,
+    /**
+     * When using href this will set link's target attribute
+     */
+    target: String,
+    /**
+     * Classes with class bindings for different elements including ({ title, image })
+     */
+    classes: {
+      type: Object,
+      default: () => ({})
+    },
+    /**
+     * Whether to proxy clicks of non-interactive elements (making whole card clickable).
+     * This is for accessibility, allowing a non-link card to have a primary action.
+     * The proxy action is determined in the following order:
+     * 1. If the title has a link (`titleTo` or `titleHref`), it will proxy the click to the title's link.
+     * 2. If not, it will look for an element with the `data-ulu-card-proxy-target` attribute within the card's slots and click it.
+     * 3. If no proxy target is found, it will emit a `proxy-click` event.
+     * Note: This should not be used with the `to` or `href` props.
+     */
+    proxyClick: Boolean,
+    /**
+     * Options to be merged for proxy click settings ({ preventSelector, preventSelectionDuration })
+     */
+    proxyClickOptions: {
+      type: Object,
+      default: () => ({})
+    },
+    /**
+     * Source of image
+     */
+    imageSrc: String,
+    /**
+     * Alt text for image
+     */
+    imageAlt: String,
+    /**
+     * If true image will use icon modifier (displays for image adjusts for icon vs full image)
+     */
+    imageIcon: Boolean,
+    /**
+     * Horizontal card layout
+     */
+    horizontal: Boolean,
+    /**
+     * Horizontal centered card layout
+     */
+    horizontalCenter: Boolean,
+    /**
+     * Overlay card layout
+     */
+    overlay: Boolean,
+    /**
+     * Class modifiers (ie. 'transparent', 'secondary', etc)
+     * - Can be String or Array of Strings
+     */
+    modifiers: [Array, String]
+  },
+  emits: ["proxy-click"],
+  setup(e, { emit: $ }) {
+    const t = e, O = $, s = N();
+    t.proxyClick && (t.to || t.href) && console.warn("UluCard: 'proxyClick' is ignored when 'to' or 'href' are present."), (t.titleTo || t.titleHref) && (t.to || t.href) && console.warn("UluCard: 'titleTo'/'titleHref' should not be used with 'to'/'href'.");
+    const T = f(null), v = f(null), { resolvedModifiers: H } = V({ props: t, baseClass: "card" }), E = f(null), c = f(!1), u = r(() => t.proxyClick && !t.to && !t.href), w = r(() => u.value && (t.titleTo || t.titleHref)), M = r(() => u.value && !w.value), g = r(() => u.value || null), z = r(() => ({
+      selectorPrevent: "input, select, textarea, button, a, [tabindex='-1']",
+      mousedownDurationPrevent: 250,
+      ...t.proxyClickOptions
+    })), j = r(() => u.value ? "pointer" : null), D = r(() => t.to ? P : t.href ? "a" : t.cardElement);
+    function U({ target: l, timeStamp: d }) {
+      if (!g.value) return;
+      const { selectorPrevent: o } = z.value;
+      c.value = !1, l.closest(o) || (c.value = !0, E.value = d);
+    }
+    function A({ timeStamp: l }) {
+      if (!g.value || !c.value) return;
+      const { mousedownDurationPrevent: d } = z.value;
+      if (l - E.value < d) {
+        if (w.value) {
+          const o = I(v.value);
+          o ? o.click() : console.warn("Unable to resolve title link ref");
+        } else if (M.value) {
+          const o = T.value?.querySelector("[data-ulu-card-proxy-target]");
+          o ? o.click() : O("proxy-click");
+        }
+      }
+      c.value = !1;
+    }
+    return (l, d) => (a(), k(B(D.value), {
+      ref_key: "cardRoot",
+      ref: T,
+      class: h(["card", [
+        {
+          "card--horizontal": e.horizontal || e.horizontalCenter,
+          "card--horizontal-center": e.horizontalCenter,
+          "card--overlay": e.overlay
+        },
+        n(H)
+      ]]),
+      onMousedown: U,
+      onMouseup: A,
+      style: R({ cursor: j.value }),
+      target: e.target,
+      to: e.to,
+      href: e.href,
+      "data-ulu-proxy-click-init": g.value
+    }, {
+      default: S(() => [
+        C("div", q, [
+          C("div", L, [
+            e.title || n(s).title ? (a(), k(B(e.titleElement), {
+              key: 0,
+              class: h(["card__title", e.classes.title])
+            }, {
+              default: S(() => [
+                e.titleTo ? (a(), k(n(P), {
+                  key: 0,
+                  class: "card__title-link",
+                  to: e.titleTo,
+                  ref_key: "link",
+                  ref: v
+                }, {
+                  default: S(() => [
+                    i(l.$slots, "title", {}, () => [
+                      x(b(e.title), 1)
+                    ])
+                  ]),
+                  _: 3
+                }, 8, ["to"])) : e.titleHref ? (a(), m("a", {
+                  key: 1,
+                  class: "card__title-link",
+                  href: e.titleHref,
+                  target: e.titleTarget,
+                  ref_key: "link",
+                  ref: v
+                }, [
+                  i(l.$slots, "title", {}, () => [
+                    x(b(e.title), 1)
+                  ])
+                ], 8, F)) : i(l.$slots, "title", { key: 2 }, () => [
+                  x(b(e.title), 1)
+                ])
+              ]),
+              _: 3
+            }, 8, ["class"])) : y("", !0),
+            i(l.$slots, "body")
+          ]),
+          n(s).aside ? (a(), m("div", G, [
+            i(l.$slots, "aside")
+          ])) : y("", !0)
+        ]),
+        n(s).image || e.imageSrc ? (a(), m("div", {
+          key: 0,
+          class: h(["card__image", [
+            { "card__image--icon": e.imageIcon },
+            e.classes.image
+          ]])
+        }, [
+          i(l.$slots, "image", {}, () => [
+            C("img", {
+              src: e.imageSrc,
+              alt: e.imageAlt
+            }, null, 8, J)
+          ])
+        ], 2)) : y("", !0),
+        n(s).footer ? (a(), m("div", K, [
+          i(l.$slots, "footer")
+        ])) : y("", !0)
+      ]),
+      _: 3
+    }, 40, ["class", "style", "target", "to", "href", "data-ulu-proxy-click-init"]));
+  }
+};
+export {
+  Z as default
+};

package/dist/components/elements/UluDefinitionList.vue.d.ts

@@ -0,0 +1,45 @@
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & (new () => {
+    $slots: S;
+});
+declare const __VLS_component: import('vue').DefineComponent<{}, {
+    classes: Record<string, any>;
+    compact: boolean;
+    inline: boolean;
+    inlineAll: boolean;
+    table: boolean;
+    separated: boolean;
+    separatedFirst: boolean;
+    separatedLast: boolean;
+    modifiers?: string | unknown[] | undefined;
+    items?: unknown[] | undefined;
+    $props: {
+        readonly classes?: Record<string, any> | undefined;
+        readonly compact?: boolean | undefined;
+        readonly inline?: boolean | undefined;
+        readonly inlineAll?: boolean | undefined;
+        readonly table?: boolean | undefined;
+        readonly separated?: boolean | undefined;
+        readonly separatedFirst?: boolean | undefined;
+        readonly separatedLast?: boolean | undefined;
+        readonly modifiers?: string | unknown[] | undefined;
+        readonly items?: unknown[] | undefined;
+    };
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDListElement>;
+type __VLS_TemplateResult = {
+    attrs: Partial<{}>;
+    slots: {
+        term?(_: {
+            item: unknown;
+            index: number;
+        }): any;
+        description?(_: {
+            item: unknown;
+            index: number;
+        }): any;
+    };
+    refs: {};
+    rootEl: HTMLDListElement;
+};
+//# sourceMappingURL=UluDefinitionList.vue.d.ts.map

package/dist/components/elements/UluDefinitionList.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UluDefinitionList.vue.d.ts","sourceRoot":"","sources":["../../../lib/components/elements/UluDefinitionList.vue"],"names":[],"mappings":"AAqBA;wBAqOqB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;;6BAEtE,CAAC,EAAE,CAAC;;;AAXjC;;;;;;;;;;;;;;;;;;;;;;;wPAQG"}

package/dist/components/elements/UluDefinitionList.vue.js

@@ -0,0 +1,98 @@
+import { computed as u, createElementBlock as l, openBlock as n, normalizeClass as a, unref as B, Fragment as b, renderList as y, createElementVNode as o, renderSlot as c, createTextVNode as d, toDisplayString as m } from "vue";
+import { useModifiers as A } from "../../composables/useModifiers.js";
+const F = {
+  __name: "UluDefinitionList",
+  props: {
+    /**
+     * Array of term, and description (props in object)
+     * - Can use slots also
+     */
+    items: Array,
+    /**
+     * Classes object for different elements { list, item, term, description }
+     */
+    classes: {
+      type: Object,
+      default: () => ({})
+    },
+    /**
+     * Class modifiers (ie. 'transparent', 'secondary', etc)
+     */
+    modifiers: [String, Array],
+    /**
+     * Displays only the definition descriptions on the same line.
+     */
+    inline: Boolean,
+    /**
+     * Displays both the definition term and its descriptions on the same line.
+     */
+    inlineAll: Boolean,
+    /**
+     * Displays the list in a two-column grid on larger screens.
+     */
+    table: Boolean,
+    /**
+     * Adds a rule between each item.
+     */
+    separated: Boolean,
+    /**
+     * Adds a rule to the top of the first item.
+     */
+    separatedFirst: Boolean,
+    /**
+     * Adds a rule to the bottom of the last item.
+     */
+    separatedLast: Boolean,
+    /**
+     * Reduces the margin between items.
+     */
+    compact: Boolean
+  },
+  setup(t) {
+    const e = t, p = u(() => ({
+      inline: e.inline,
+      "inline-all": e.inlineAll,
+      table: e.table,
+      separated: e.separated,
+      "separated-first": e.separatedFirst,
+      "separated-last": e.separatedLast,
+      compact: e.compact
+    })), { resolvedModifiers: f } = A({
+      props: e,
+      internal: p,
+      baseClass: "definition-list"
+    });
+    return (r, L) => (n(), l("dl", {
+      class: a(["definition-list", [B(f), t.classes.list]])
+    }, [
+      (n(!0), l(b, null, y(t.items, (s, i) => (n(), l("div", {
+        key: i,
+        class: a(t.classes.item)
+      }, [
+        o("dt", {
+          class: a(t.classes.term)
+        }, [
+          c(r.$slots, "term", {
+            item: s,
+            index: i
+          }, () => [
+            d(m(s.term), 1)
+          ])
+        ], 2),
+        o("dd", {
+          class: a(t.classes.description)
+        }, [
+          c(r.$slots, "description", {
+            item: s,
+            index: i
+          }, () => [
+            d(m(s.description), 1)
+          ])
+        ], 2)
+      ], 2))), 128))
+    ], 2));
+  }
+};
+export {
+  F as default
+};

package/dist/components/elements/UluExternalLink.vue.d.ts

@@ -0,0 +1,26 @@
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & (new () => {
+    $slots: S;
+});
+declare const __VLS_component: import('vue').DefineComponent<{}, {
+    target: string;
+    icon?: string | undefined;
+    text?: string | undefined;
+    href?: string | undefined;
+    $props: {
+        readonly target?: string | undefined;
+        readonly icon?: string | undefined;
+        readonly text?: string | undefined;
+        readonly href?: string | undefined;
+    };
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLAnchorElement>;
+type __VLS_TemplateResult = {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLAnchorElement;
+};
+//# sourceMappingURL=UluExternalLink.vue.d.ts.map

package/dist/components/elements/UluExternalLink.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UluExternalLink.vue.d.ts","sourceRoot":"","sources":["../../../lib/components/elements/UluExternalLink.vue"],"names":[],"mappings":"AAWA;wBAwIqB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;;6BAEtE,CAAC,EAAE,CAAC;;;AAXjC;;;;;;;;;;;yPAQG"}