@witchcraft/ui 0.0.1

package/dist/runtime/helpers/NotificationHandler.js

@@ -0,0 +1,162 @@
+import { castType } from "@alanscodelog/utils/castType.js";
+import { crop } from "@alanscodelog/utils/crop.js";
+import { indent } from "@alanscodelog/utils/indent.js";
+import { isBlank } from "@alanscodelog/utils/isBlank.js";
+import { pretty } from "@alanscodelog/utils/pretty.js";
+import { setReadOnly } from "@alanscodelog/utils/setReadOnly.js";
+export class NotificationHandler {
+  timeout = 5e3;
+  debug = false;
+  id = 0;
+  queue = [];
+  history = [];
+  maxHistory = 100;
+  listeners = [];
+  stringifier;
+  constructor({
+    timeout,
+    stringifier,
+    maxHistory
+  } = {}) {
+    if (timeout) this.timeout = timeout;
+    if (maxHistory) this.maxHistory = maxHistory;
+    if (stringifier) this.stringifier = stringifier;
+  }
+  _checkEntry(entry) {
+    if (entry.cancellable !== void 0 && isBlank(entry.cancellable)) {
+      throw new Error(
+        crop`Cancellable cannot be a blank string:
+					${indent(pretty(entry), 5)}
+				`
+      );
+    }
+    if (!entry.options.includes(entry.default)) {
+      throw new Error(
+        crop`Entry options does not include default option "${entry.default}":
+					${indent(pretty(entry), 5)}
+				`
+      );
+    }
+    if (entry.cancellable) {
+      if (typeof entry.cancellable === "string" && !entry.options.includes(entry.cancellable)) {
+        throw new Error(
+          crop`Entry options does not include cancellable option "${entry.cancellable}":
+						${indent(pretty(entry), 6)}
+					`
+        );
+      }
+    } else {
+      if (entry.options.includes("Cancel")) {
+        throw new Error(
+          crop`You specified that the entry should not be cancellable, but the options include the "Cancel" option:
+						${indent(pretty(entry), 6)}
+					`
+        );
+      }
+    }
+    if (entry.timeout !== void 0 && !entry.cancellable) {
+      throw new Error(
+        crop`Cannot timeout notification that is not cancellable:
+					${indent(pretty(entry), 5)}
+					`
+      );
+    }
+    if (entry.timeout !== void 0 && entry.requiresAction) {
+      throw new Error(
+        crop`Cannot timeout notification that requires action:
+					${indent(pretty(entry), 5)}
+					`
+      );
+    }
+    const missingDangerousOption = entry.dangerous.find((option) => !entry.options.includes(option));
+    if (entry.dangerous !== void 0 && missingDangerousOption) {
+      throw new Error(
+        crop`Dangerous options list contains an unknown option "${missingDangerousOption}":
+					${indent(pretty(entry), 5)}
+				`
+      );
+    }
+  }
+  _createEntry(rawEntry) {
+    const entry = {
+      requiresAction: false,
+      options: ["Ok", "Cancel"],
+      default: "Ok",
+      cancellable: rawEntry.cancellable,
+      ...rawEntry,
+      dangerous: rawEntry.dangerous ?? [],
+      timeout: rawEntry.timeout === true ? this.timeout : rawEntry.timeout !== void 0 && rawEntry.timeout !== false ? rawEntry.timeout : void 0
+    };
+    if (rawEntry.cancellable === true || rawEntry.cancellable === void 0 && entry.options?.includes("Cancel")) {
+      entry.cancellable = "Cancel";
+    }
+    this._checkEntry(entry);
+    castType(entry);
+    this.id++;
+    entry.id = this.id;
+    return entry;
+  }
+  async notify(rawEntry) {
+    const entry = this._createEntry(rawEntry);
+    entry.promise = new Promise((_resolve) => {
+      entry.resolve = _resolve;
+    });
+    if (entry.timeout !== void 0) {
+      setTimeout(() => {
+        entry.resolve(entry.cancellable);
+      }, entry.timeout);
+    }
+    this.queue.push(entry);
+    for (const listener of this.listeners) {
+      listener(entry, "added");
+    }
+    return entry.promise.then((res) => {
+      entry.resolution = res;
+      for (const listener of this.listeners) {
+        listener(entry, "resolved");
+      }
+      this.history.push(entry);
+      if (this.history.length > this.maxHistory) {
+        this.history.splice(0, 1);
+        for (const listener of this.listeners) {
+          listener(entry, "deleted");
+        }
+      }
+      this.queue.splice(this.queue.indexOf(entry), 1);
+      return res;
+    });
+  }
+  static resolveToDefault(notification) {
+    notification.resolve(notification.default);
+  }
+  static dismiss(notification) {
+    if (notification.cancellable) {
+      notification.resolve(notification.cancellable);
+    }
+  }
+  stringify(notification) {
+    if (this.stringifier) return this.stringifier(notification);
+    let str = "";
+    if (notification.title) str += `${notification.title}
+`;
+    str += `${notification.message}
+`;
+    if (notification.code) str += `code:${notification.code}
+`;
+    return str;
+  }
+  clear() {
+    setReadOnly(this, "history", []);
+  }
+  addNotificationListener(cb) {
+    this.listeners.push(cb);
+  }
+  removeNotificationListener(cb) {
+    const exists = this.listeners.indexOf(cb);
+    if (exists > -1) {
+      this.listeners.splice(exists, 1);
+    } else {
+      throw new Error(`Listener does not exist: ${cb.toString()}`);
+    }
+  }
+}

package/dist/runtime/helpers/addValue.d.ts

@@ -0,0 +1 @@
+export declare const addValue: <T>(value: T, values: T[], preventDuplicateValues: boolean) => T[];

package/dist/runtime/helpers/addValue.js

@@ -0,0 +1,8 @@
+import { pushIfNotIn } from "@alanscodelog/utils/pushIfNotIn.js";
+export const addValue = (value, values, preventDuplicateValues) => {
+  if (preventDuplicateValues) {
+    return pushIfNotIn(values, [value]);
+  }
+  values.push(value);
+  return values;
+};

package/dist/runtime/helpers/base64ToImg.d.ts

@@ -0,0 +1 @@
+export declare const base64ToImg: (imageSrc: string) => Promise<HTMLImageElement>;

package/dist/runtime/helpers/base64ToImg.js

@@ -0,0 +1,11 @@
+export const base64ToImg = async (imageSrc) => {
+  const img = new Image();
+  const loaded = new Promise((resolve) => {
+    img.addEventListener("load", () => {
+      resolve(img);
+    });
+  });
+  img.src = imageSrc;
+  await loaded;
+  return img;
+};

package/dist/runtime/helpers/copy.d.ts

@@ -0,0 +1 @@
+export declare const copy: (text: string) => void;

package/dist/runtime/helpers/copy.js

@@ -0,0 +1,10 @@
+export const copy = (text) => {
+  if (navigator.clipboard) {
+    navigator.clipboard.writeText(text).catch((err) => {
+      console.warn(`There was an error copying to the clipboard, please file a bug report.
+${err}`);
+    });
+  } else {
+    console.warn("Could not copy to clipboard, your browser is not supported.");
+  }
+};

package/dist/runtime/helpers/createNoonUtcDate.d.ts

@@ -0,0 +1,7 @@
+import { type CalendarDate, ZonedDateTime } from "@internationalized/date";
+/**
+ * Takes the given local DATE (ignores the time), and converts it to a UTC (0 offset) date at noon.
+ *
+ * This should be used to wrap fallback dates for timeless dates, so that the date never changes regardless of the timezone it's converted too.
+ */
+export declare function createNoonUtcDate(date: CalendarDate): ZonedDateTime;

package/dist/runtime/helpers/createNoonUtcDate.js

@@ -0,0 +1,14 @@
+import { ZonedDateTime } from "@internationalized/date";
+export function createNoonUtcDate(date) {
+  const noon = [12, 0, 0];
+  const timeZoneOffset = 0;
+  const d = new ZonedDateTime(
+    date.year,
+    date.month,
+    date.day,
+    "UTC",
+    timeZoneOffset,
+    ...noon
+  );
+  return d;
+}

package/dist/runtime/helpers/defaultTranslationFunction.d.ts

@@ -0,0 +1,16 @@
+/**
+ * A default translation function to use with `useSetupI18n`. Requires at least one set of translation message sets (or a dummy) be loaded (the useSetupI18n function takes care of setting up a temporary dummy if you set `useBuiltinTranslations: true`).
+ *
+ * It can take a simple replacement object as the second argument, it's keys in the form `{key}` will be replace with the given value.
+ *
+ * For example:
+ * ```js
+ * const messages = {
+ * 	"some-message": "This is a {key}",
+ * }
+ *
+ * t("some-message", { key: "message" })
+ * ```
+ * Would return "This is a message".
+ */
+export declare function defaultTranslationFunction(key: string, replacements?: Record<string, any>): string;

package/dist/runtime/helpers/defaultTranslationFunction.js

@@ -0,0 +1,14 @@
+import { inject } from "vue";
+import { translationMessagesInjectionKey } from "../composables/useSetupI18n.js";
+export function defaultTranslationFunction(key, replacements) {
+  const messages = inject(translationMessagesInjectionKey);
+  if (messages === void 0) throw new Error("witchcraft/ui: The default translation function requires the useSetupI18n `useBuiltinTranslations` options to be true. Did you set it?");
+  let value = messages.value["witchcraft-ui"][key];
+  if (value === void 0) throw new Error(`No translation for key ${key}.`);
+  if (replacements !== void 0) {
+    for (const [k, val] of Object.entries(replacements)) {
+      value = value.replaceAll(`{${k}}`, val);
+    }
+  }
+  return value;
+}

package/dist/runtime/helpers/getTimeZoneList.d.ts

@@ -0,0 +1 @@
+export declare function getTimeZoneList(): string[];

package/dist/runtime/helpers/getTimeZoneList.js

@@ -0,0 +1,3 @@
+export function getTimeZoneList() {
+  return Intl.supportedValuesOf("timeZone");
+}

package/dist/runtime/helpers/hasModifiers.d.ts

@@ -0,0 +1 @@
+export declare const hasModifiers: (e: KeyboardEvent) => boolean;

package/dist/runtime/helpers/hasModifiers.js

@@ -0,0 +1 @@
+export const hasModifiers = (e) => e.ctrlKey || e.altKey || e.shiftKey || e.metaKey;

package/dist/runtime/helpers/index.d.ts

@@ -0,0 +1,8 @@
+export { addValue } from "./addValue.js.js";
+export { base64ToImg } from "./base64ToImg.js.js";
+export { copy } from "./copy.js.js";
+export { createRecorderHandler } from "./storybook.js.js";
+export { hasModifiers } from "./hasModifiers.js.js";
+export { NotificationHandler } from "./NotificationHandler.js.js";
+export { readFile } from "./readFile.js.js";
+export { ResizeObserverWrapper } from "./resizeObserverWrapper.js.js";

package/dist/runtime/helpers/index.js

@@ -0,0 +1,8 @@
+export { addValue } from "./addValue.js";
+export { base64ToImg } from "./base64ToImg.js";
+export { copy } from "./copy.js";
+export { createRecorderHandler } from "./storybook.js";
+export { hasModifiers } from "./hasModifiers.js";
+export { NotificationHandler } from "./NotificationHandler.js";
+export { readFile } from "./readFile.js";
+export { ResizeObserverWrapper } from "./resizeObserverWrapper.js";

package/dist/runtime/helpers/readFile.d.ts

@@ -0,0 +1 @@
+export declare const readFile: <TType extends "DataUrl" | "ArrayBuffer" | "BinaryString" | "text" = "DataUrl">(file?: File | Blob, type?: TType) => Promise<TType extends "ArrayBuffer" ? ArrayBuffer : string>;

package/dist/runtime/helpers/readFile.js

@@ -0,0 +1,13 @@
+export const readFile = async (file, type = "DataUrl") => new Promise((resolve, reject) => {
+  const reader = new FileReader();
+  reader.addEventListener("load", () => {
+    resolve(reader.result);
+  }, false);
+  reader.addEventListener("error", () => {
+    reject(new Error(reader.result));
+  }, false);
+  if (type === "DataUrl") reader.readAsDataURL(file);
+  if (type === "ArrayBuffer") reader.readAsArrayBuffer(file);
+  if (type === "BinaryString") reader.readAsBinaryString(file);
+  if (type === "text") reader.readAsText(file);
+});

package/dist/runtime/helpers/resizeObserverWrapper.d.ts

@@ -0,0 +1,8 @@
+import type { ResizeCallback } from "../types/index.js.js";
+export declare class ResizeObserverWrapper {
+    observers: WeakMap<Element, Set<ResizeCallback>>;
+    observer: ResizeObserver;
+    constructor();
+    observe(element: Element, callback: ResizeCallback): void;
+    unobserve(element: Element, callback: ResizeCallback): void;
+}

package/dist/runtime/helpers/resizeObserverWrapper.js

@@ -0,0 +1,37 @@
+export class ResizeObserverWrapper {
+  observers = /* @__PURE__ */ new WeakMap();
+  observer;
+  constructor() {
+    this.observers = /* @__PURE__ */ new WeakMap();
+    this.observer = new ResizeObserver((elements) => {
+      for (const element of elements) {
+        const { target, contentRect } = element;
+        const callbacks = this.observers.get(target);
+        if (callbacks) {
+          for (const cb of callbacks) {
+            cb(contentRect, target);
+          }
+        }
+      }
+    });
+  }
+  observe(element, callback) {
+    const entry = this.observers.get(element);
+    if (!entry) {
+      this.observers.set(element, /* @__PURE__ */ new Set());
+    }
+    this.observer.observe(element);
+    const callbacks = this.observers.get(element);
+    callbacks.add(callback);
+  }
+  unobserve(element, callback) {
+    const entry = this.observers.get(element);
+    if (!entry) return;
+    const callbacks = this.observers.get(element);
+    callbacks.delete(callback);
+    if (callbacks.size === 0) {
+      this.observer.unobserve(element);
+      this.observers.delete(element);
+    }
+  }
+}

package/dist/runtime/helpers/storybook.d.ts

@@ -0,0 +1,7 @@
+import type { Ref } from "vue";
+export declare const createRecorderHandler: (recordingValue: Ref<string>, recording: Ref<boolean>, modelValue: Ref<string>, recordingEl: Ref<null | HTMLElement>) => {
+    keydown(e: KeyboardEvent): void;
+    mousedown(e: MouseEvent): void;
+    wheel(e: WheelEvent): void;
+};
+export declare const createRecorderWatchEffect: (recordingValue: Ref<string>, recording: Ref<boolean>, modelValue: Ref<string>, values?: Ref<string[]>) => () => void;

package/dist/runtime/helpers/storybook.js

@@ -0,0 +1,42 @@
+import { hasModifiers } from "./hasModifiers.js";
+export const createRecorderHandler = (recordingValue, recording, modelValue, recordingEl) => ({
+  keydown(e) {
+    e.preventDefault();
+    if (!hasModifiers(e) && e.key === "Escape") {
+      recordingValue.value = modelValue.value;
+      recording.value = false;
+      return;
+    }
+    if (!hasModifiers(e) && e.key === "Enter") {
+      recording.value = false;
+      return;
+    }
+    recordingValue.value += ` ${e.key}`;
+  },
+  mousedown(e) {
+    const target = e.target;
+    const el = recordingEl.value;
+    if (target === el || el?.contains(target)) {
+      return;
+    }
+    recordingValue.value += ` ${e.button}`;
+    e.preventDefault();
+  },
+  wheel(e) {
+    recordingValue.value += ` ${e.deltaY > 0 ? "\u2193" : "\u2191"}`;
+    e.preventDefault();
+  }
+});
+export const createRecorderWatchEffect = (recordingValue, recording, modelValue, values) => () => {
+  if (!recording.value) {
+    if (recordingValue.value) {
+      if (values?.value) {
+        values.value.push(recordingValue.value);
+        modelValue.value = "";
+      } else {
+        modelValue.value = recordingValue.value;
+      }
+    }
+    recordingValue.value = "";
+  }
+};

package/dist/runtime/main.lib.d.ts

@@ -0,0 +1,26 @@
+export * from "./types/index.js.js";
+export * as components from "./components/index.js.js";
+export * as helpers from "./helpers/index.js.js";
+export * as composables from "./composables/index.js.js";
+export * as directives from "./directives/index.js.js";
+export { registerDirectives } from "./vue/registerDirectives.js.js";
+export { registerComponents } from "./vue/registerComponents.js.js";
+export { VueComponentsPlugin } from "./vue/VueComponentsPlugin.js.js";
+import type * as components from "./components/index.js.js";
+type Components = typeof components;
+/**
+ * To get global typings, in a global declaration file (e.g. global.d.ts) do:
+ *
+ * ```ts
+ * import { GlobalComponentTypes } from "@witchcraft/ui"
+ *
+ * declare module "@vue/runtime-core" {
+ * 	export interface GlobalComponents extends GlobalComponentTypes { }
+ * }
+ * export {}
+ * ```
+ * To be able to pass extra attributes you will have to have a global declaration file like the one the library has ({@link ./global.d.ts}), see https://github.com/vuejs/language-tools/issues/1077#issuecomment-1145960878
+ */
+export type GlobalComponentTypes = {
+    [key in keyof Components]: Components[key];
+};

package/dist/runtime/main.lib.js

@@ -0,0 +1,8 @@
+export * from "./types/index.js";
+export * as components from "./components/index.js";
+export * as helpers from "./helpers/index.js";
+export * as composables from "./composables/index.js";
+export * as directives from "./directives/index.js";
+export { registerDirectives } from "./vue/registerDirectives.js";
+export { registerComponents } from "./vue/registerComponents.js";
+export { VueComponentsPlugin } from "./vue/VueComponentsPlugin.js";

package/dist/runtime/nuxt/plugins/vue-plugin.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("nuxt/app").Plugin<Record<string, unknown>> & import("nuxt/app").ObjectPlugin<Record<string, unknown>>;
+export default _default;

package/dist/runtime/nuxt/plugins/vue-plugin.js

@@ -0,0 +1,12 @@
+import { isArray } from "@alanscodelog/utils/isArray.js";
+import { defineNuxtPlugin, useRuntimeConfig } from "#imports";
+import { registerDirectives } from "../../vue/registerDirectives.js";
+export default defineNuxtPlugin({
+  name: "components-plugin",
+  async setup(nuxtApp) {
+    const config = useRuntimeConfig().public.witchcraftUi;
+    const app = nuxtApp.vueApp;
+    const directives = isArray(config?.directives) ? (await Promise.all(config.directives.map(async (name) => import(`../../directives/${name}.ts`)))).map((_) => Object.values(_)[0]) : await import("../../directives/index.ts");
+    registerDirectives(app, Object.values(directives));
+  }
+});

package/dist/runtime/tailwind/index.d.ts

@@ -0,0 +1 @@
+export { themeConvertionOpts } from "./themeConvertionOpts.js.js";

package/dist/runtime/tailwind/index.js

@@ -0,0 +1 @@
+export { themeConvertionOpts } from "./themeConvertionOpts.js";

package/dist/runtime/tailwind/themeConvertionOpts.d.ts

@@ -0,0 +1,2 @@
+import { type themeAsTailwindCss } from "metamorphosis/tailwind.js";
+export declare const themeConvertionOpts: Parameters<typeof themeAsTailwindCss>[1];

package/dist/runtime/tailwind/themeConvertionOpts.js

@@ -0,0 +1,12 @@
+export const themeConvertionOpts = {
+  topLevel: ["number-spacing"],
+  twTypeMap: { color: "colors" },
+  // note, not available yet
+  defaultsMap: {
+    "color-neutral": "50",
+    "color-warning": "500",
+    "color-ok": "500",
+    "color-error": "500",
+    "color-accent": "500"
+  }
+};

package/dist/runtime/theme.d.ts

@@ -0,0 +1,2 @@
+import type { Theme } from "metamorphosis/Theme.js";
+export declare const theme: Theme;

package/dist/runtime/theme.js

@@ -0,0 +1,2 @@
+import { baseTheme } from "metamorphosis/BaseTheme.js";
+export const theme = baseTheme;

package/dist/runtime/types/index.d.ts

@@ -0,0 +1,119 @@
+import type { ErrorW } from "@alanscodelog/utils";
+import { type Ref } from "vue";
+export type ResizableOptions = {
+    /**
+     * Defaults to true.
+     *
+     * ### true
+     * The directive will shrink/expand the columns when the table is resized and will use percentage widths on the table cells. This disables resizing of the last column (from the right handle).
+     *
+     * Additionally because of the way `table-layout:fixed` works, a min-width cannot be set on the elements via css, so instead, if the table shrinks past `opts.margin * col #`, `min-width` is set on the table until it's resized larger.
+     *
+     * Note that by definition, the columns are not resizable when this happens.
+     *
+     * ### false
+     *
+     * The table can be resized past it's normal width and uses pixel widths on the table cells. You might want to set `overscroll-x: scroll` on a parent wrapping element.
+     *
+     * This will set the table width to `min-content`, else it doesn't work. Note that it does this after the initial reading/setting of sizes so you can, for example, layout the table with `width: 100%`.
+     */
+    fitWidth: boolean;
+    /**
+     * The minimum width a column can have.
+     *
+     * Can be a number, or "dynamic". When dynamic, the directive attempts to get the width of `.grip` and multiplies it times 3.
+     */
+    margin: "dynamic" | number;
+    /**
+     * Whether resizing is enabled.
+     *
+     * Can be turned off and all listeners, grips, etc, will be removed.
+     *
+     * Note that element styles set are not removed.
+     */
+    enabled: boolean;
+    /** The number of columns. It will be assumed the first colCount elements are the initial widths of the table columns. */
+    colCount: number;
+    /**
+     * A ref that gets filled in with the element width string values by the directive.
+     *
+     * It can then be used as needed by the component.
+     */
+    widths: Ref<string[]>;
+    /** The selector to use for the cells. "tr > td" by default. */
+    selector: string;
+};
+export type TableColConfig<T = {}> = Record<keyof T, {
+    name?: string;
+    resizable?: boolean;
+}>;
+export type ResizeCallback = (_rect: DOMRectReadOnly, el: Element) => void;
+export type FileInputError = ErrorW<{
+    file: File;
+    isValidMimeType: boolean;
+    isValidExtension: boolean;
+}>;
+export type HsvaColor = {
+    h: number;
+    s: number;
+    v: number;
+    a?: number;
+};
+export type RgbaColor = {
+    r: number;
+    g: number;
+    b: number;
+    a?: number;
+};
+export type ScrollNearContainerEdgesOptions = {
+    containerEl: Ref<HTMLElement | null>;
+    /** Margin inside contianer that allows scrolling. 10 by default. */
+    scrollMargin?: number;
+    /** Margin around container that still allows scrolling. 0 by defualt. */
+    outerScrollMargin?: number;
+    /**
+        * Controls the scrolling speed.
+        *
+        *  Scroll happens faster the nearer to the outer edge the cursor.
+        *
+        * This is calculated as a percent (0 near the inner edge, and 1 near the outer edge), which is then multiplied by this multiplier, since moving by less than 1 pixel is quite slow. The default is 4.
+        */
+    fastPixelMultiplier?: number;
+    /** @deprecated Use fastPixelMultiplier instead. */
+    fastPixelAmount?: number;
+    useTimer?: boolean;
+    timerInterval?: number;
+};
+export type SimpleDOMRect = Omit<DOMRect, "toJSON">;
+export interface IPopupReference {
+    getBoundingClientRect: () => SimpleDOMRect;
+}
+export type PopupPosition = {
+    x: number;
+    y: number;
+    maxWidth?: number;
+    maxHeight?: number;
+};
+export type PopupSpaceInfo = {
+    left: number;
+    right: number;
+    leftLeft: number;
+    rightRight: number;
+    leftFromCenter: number;
+    rightFromCenter: number;
+    topFromCenter: number;
+    bottomFromCenter: number;
+    top: number;
+    bottom: number;
+};
+export type PopupPositioner = (
+/** Reference is only undefined, if you did not specify a button element or use the exposed setReference. The function is still called, because there are other ways you might want to still position the popup (e.g. center-screen or some similar variation). */
+reference: SimpleDOMRect | undefined, popup: SimpleDOMRect | DOMRect, bg: SimpleDOMRect | DOMRect, space: PopupSpaceInfo) => number;
+export type PopupPositionModifier = (pos: PopupPosition, 
+/** This will only be called with the reference element as undefined when one of the preferred positions is center-screen or it's a function. */
+reference: SimpleDOMRect | undefined, popup: SimpleDOMRect | DOMRect, bg: SimpleDOMRect | DOMRect, space: PopupSpaceInfo) => PopupPosition;
+export type SingleDate = Date | undefined;
+export type RangeDate = {
+    start?: SingleDate;
+    end?: SingleDate;
+};

package/dist/runtime/utils/twMerge.d.ts

@@ -0,0 +1,10 @@
+export declare const twMerge: (...classLists: import("tailwind-merge").ClassNameValue[]) => string;
+export declare const twMergeExtend: {
+    extend: {
+        classGroups: {
+            "focus-outline": {
+                "focus-outline": string[];
+            }[];
+        };
+    };
+};

package/dist/runtime/utils/twMerge.js

@@ -0,0 +1,10 @@
+import { extendTailwindMerge } from "tailwind-merge";
+const _twMergeExtend = {
+  extend: {
+    classGroups: {
+      "focus-outline": [{ "focus-outline": ["", "no-offset", "none"] }]
+    }
+  }
+};
+export const twMerge = extendTailwindMerge(_twMergeExtend);
+export const twMergeExtend = _twMergeExtend;

package/dist/runtime/vue/VueComponentsPlugin.d.ts

@@ -0,0 +1,2 @@
+import type { Plugin } from "vue";
+export declare const VueComponentsPlugin: Plugin;