nuxt-ui-elements 0.1.16 → 0.1.18

package/dist/module.json

@@ -1,7 +1,7 @@
 {
   "name": "nuxt-ui-elements",
   "configKey": "uiElements",
-  "version": "0.1.16",
+  "version": "0.1.18",
   "builder": {
     "@nuxt/module-builder": "1.0.2",
     "unbuild": "3.6.1"

package/dist/runtime/utils/std/date.d.ts

@@ -0,0 +1,213 @@
+/**
+ * Date utilities built on @internationalized/date
+ * Provides tree-shakeable functional API for date manipulation
+ *
+ * @example
+ * import { add, format, today } from '#std/date'
+ *
+ * const nextMonth = add(today(), 1, 'month')
+ * const formatted = format(nextMonth, 'MMMM D, YYYY') // "January 15, 2024"
+ */
+import type { CalendarDate, CalendarDateTime, DateValue, ZonedDateTime } from "@internationalized/date";
+import { getDayOfWeek, getLocalTimeZone, getWeeksInMonth, isSameDay, isSameMonth, isSameYear, isToday, isWeekend } from "@internationalized/date";
+/**
+ * Add time to a date
+ * @param input - The date to add to
+ * @param amount - The amount to add
+ * @param unit - The unit of time to add
+ * @returns The new date with time added
+ * @example
+ * add(someDate, 1, 'month')
+ * add(someDate, 7, 'day')
+ */
+export declare function add(input: Date | string | DateValue, amount: number, unit: "day" | "week" | "month" | "year" | "hour" | "minute" | "second"): DateValue;
+/**
+ * Subtract time from a date
+ * @param input - The date to subtract from
+ * @param amount - The amount to subtract
+ * @param unit - The unit of time to subtract
+ * @returns The new date with time subtracted
+ * @example
+ * subtract(someDate, 1, 'month')
+ * subtract(someDate, 7, 'day')
+ */
+export declare function subtract(input: Date | string | DateValue, amount: number, unit: "day" | "week" | "month" | "year" | "hour" | "minute" | "second"): DateValue;
+/**
+ * Set specific date/time values
+ * @param input - The date to modify
+ * @param values - Object containing the date/time values to set
+ * @returns The new date with values set
+ * @example
+ * set(someDate, { day: 15, month: 3 })
+ */
+export declare function set(input: Date | string | DateValue, values: {
+    year?: number;
+    month?: number;
+    day?: number;
+    hour?: number;
+    minute?: number;
+    second?: number;
+}): DateValue;
+/**
+ * Convert to native JavaScript Date object
+ * @param input - The date to convert
+ * @param timeZone - Optional timezone (defaults to local timezone)
+ * @returns JavaScript Date object
+ * @example
+ * toDate(someDate)
+ */
+export declare function toDate(input: Date | string | DateValue, timeZone?: string): Date;
+/**
+ * Format the date using Day.js-compatible format tokens
+ *
+ * Supports all standard Day.js tokens: YYYY, MM, DD, HH, mm, ss, etc.
+ * For a complete list of format tokens, see: https://day.js.org/docs/en/display/format
+ *
+ * @param input - The date to format
+ * @param formatString - Format string using Day.js tokens (default: 'YYYY-MM-DD')
+ * @param locale - Locale for month/weekday names (default: 'en-US')
+ * @returns Formatted date string
+ * @example
+ * format(someDate, 'YYYY-MM-DD')
+ * format(someDate, 'DD/MM/YYYY HH:mm:ss')
+ * format(someDate, 'MMMM D, YYYY')
+ * format(someDate, 'MMM DD, YYYY h:mm A')
+ */
+export declare function format(input: Date | string | DateValue, formatString?: string, locale?: string): string;
+/**
+ * Get relative time string (e.g., "2 days ago", "in 3 months")
+ * @param input - The date to compare against now
+ * @param locale - Locale for the relative time format (default: 'en-US')
+ * @returns Relative time string
+ * @example
+ * relative(someDate) // "2 days ago"
+ * relative(futureDate) // "in 3 months"
+ */
+export declare function relative(input: Date | string | DateValue, locale?: string): string;
+/**
+ * Convert to CalendarDate (date without time)
+ * @param input - The date to convert
+ * @returns CalendarDate object
+ * @example
+ * asCalendarDate(someDate)
+ */
+export declare function asCalendarDate(input: Date | string | DateValue): CalendarDate;
+/**
+ * Convert to CalendarDateTime (date with time, no timezone)
+ * @param input - The date to convert
+ * @returns CalendarDateTime object
+ * @example
+ * asCalendarDateTime(someDate)
+ */
+export declare function asCalendarDateTime(input: Date | string | DateValue): CalendarDateTime;
+/**
+ * Convert to ZonedDateTime (date with time and timezone)
+ * @param input - The date to convert
+ * @param timeZone - Optional timezone (defaults to local timezone)
+ * @returns ZonedDateTime object
+ * @example
+ * asZonedDateTime(someDate, 'America/New_York')
+ */
+export declare function asZonedDateTime(input: Date | string | DateValue, timeZone?: string): ZonedDateTime;
+/**
+ * Check if this date is before another date
+ * @param input - The first date
+ * @param other - The date to compare against
+ * @returns True if input is before other
+ * @example
+ * isBefore(date1, date2)
+ */
+export declare function isBefore(input: Date | string | DateValue, other: DateValue | Date | string): boolean;
+/**
+ * Check if this date is after another date
+ * @param input - The first date
+ * @param other - The date to compare against
+ * @returns True if input is after other
+ * @example
+ * isAfter(date1, date2)
+ */
+export declare function isAfter(input: Date | string | DateValue, other: DateValue | Date | string): boolean;
+/**
+ * Check if this date is the same as another date
+ * @param input - The first date
+ * @param other - The date to compare against
+ * @returns True if dates are equal
+ * @example
+ * isSame(date1, date2)
+ */
+export declare function isSame(input: Date | string | DateValue, other: DateValue | Date | string): boolean;
+/**
+ * Calculate the difference between two dates
+ * @param input - The first date
+ * @param other - The second date to subtract
+ * @param unit - The unit to return the difference in (default: 'millisecond')
+ * @returns The difference between the two dates in the specified unit
+ * @example
+ * diff(date1, date2, 'days') // returns number of days between dates
+ * diff(date1, date2, 'hours') // returns number of hours between dates
+ */
+export declare function diff(input: Date | string | DateValue, other: Date | string | DateValue, unit?: "year" | "month" | "week" | "day" | "hour" | "minute" | "second" | "millisecond"): number;
+/**
+ * Check if a date is between two other dates
+ * @param input - The date to check
+ * @param start - The start date of the range
+ * @param end - The end date of the range
+ * @param inclusive - Whether to include the start and end dates (default: true)
+ * @returns True if the date is within the range
+ * @example
+ * isBetween(date, startDate, endDate) // true if date is between start and end (inclusive)
+ * isBetween(date, startDate, endDate, false) // exclusive check
+ */
+export declare function isBetween(input: Date | string | DateValue, start: Date | string | DateValue, end: Date | string | DateValue, inclusive?: boolean): boolean;
+/**
+ * Start of a time period
+ * @param input - The date to get the start of
+ * @param unit - The time period unit
+ * @param locale - Locale for week start calculation (default: 'en-US')
+ * @returns The start of the specified time period
+ * @example
+ * startOf(someDate, 'month')
+ * startOf(someDate, 'week', 'en-US')
+ */
+export declare function startOf(input: Date | string | DateValue, unit: "day" | "week" | "month" | "year", locale?: string): CalendarDate;
+/**
+ * End of a time period
+ * @param input - The date to get the end of
+ * @param unit - The time period unit
+ * @param locale - Locale for week end calculation (default: 'en-US')
+ * @returns The end of the specified time period
+ * @example
+ * endOf(someDate, 'month')
+ * endOf(someDate, 'week', 'en-US')
+ */
+export declare function endOf(input: Date | string | DateValue, unit: "day" | "week" | "month" | "year", locale?: string): CalendarDate;
+/**
+ * Get today's date
+ * @param timeZone - Optional timezone (defaults to local timezone)
+ * @returns Today's date as a CalendarDate
+ * @example
+ * today()
+ */
+export declare function today(timeZone?: string): CalendarDate;
+/**
+ * Get current date and time
+ * @param timeZone - Optional timezone (defaults to local timezone)
+ * @returns Current date and time as a ZonedDateTime
+ * @example
+ * now()
+ */
+export declare function now(timeZone?: string): ZonedDateTime;
+/**
+ * Parse a date string
+ * @param dateString - Date string in YYYY-MM-DD format
+ * @returns Parsed CalendarDate
+ * @example
+ * parse('2024-01-15')
+ */
+export declare function parse(dateString: string): CalendarDate;
+/**
+ * Re-export useful utilities from @internationalized/date
+ * that complement (not duplicate) the main API
+ */
+export { isSameDay, isSameMonth, isSameYear, isToday, isWeekend, getDayOfWeek, getWeeksInMonth, getLocalTimeZone, };
+export type { CalendarDate, CalendarDateTime, DateValue, ZonedDateTime };

package/dist/runtime/utils/std/date.js

@@ -0,0 +1,307 @@
+import {
+  endOfWeek,
+  getDayOfWeek,
+  getLocalTimeZone,
+  getWeeksInMonth,
+  isSameDay,
+  isSameMonth,
+  isSameYear,
+  isToday,
+  isWeekend,
+  now as nowFromLib,
+  parseDate,
+  parseDateTime,
+  parseZonedDateTime,
+  startOfWeek,
+  toCalendarDate,
+  toCalendarDateTime,
+  today as todayFromLib
+} from "@internationalized/date";
+function parseDateInput(input) {
+  if (!input) {
+    return todayFromLib(getLocalTimeZone());
+  }
+  if (typeof input === "object" && "calendar" in input) {
+    return input;
+  }
+  if (input instanceof Date) {
+    const isoString = input.toISOString();
+    if (isoString.endsWith("T00:00:00.000Z")) {
+      const datePart = isoString.split("T")[0];
+      if (datePart) {
+        return parseDate(datePart);
+      }
+    }
+    return parseZonedDateTime(isoString);
+  }
+  if (typeof input === "string") {
+    if (input.includes("T") || input.includes(" ")) {
+      try {
+        return parseZonedDateTime(input);
+      } catch {
+        try {
+          return parseDateTime(input);
+        } catch {
+          const datePart = input.split("T")[0]?.split(" ")[0];
+          if (datePart) {
+            return parseDate(datePart);
+          }
+        }
+      }
+    }
+    return parseDate(input);
+  }
+  return todayFromLib(getLocalTimeZone());
+}
+export function add(input, amount, unit) {
+  const dateValue = parseDateInput(input);
+  return dateValue.add({ [unit + "s"]: amount });
+}
+export function subtract(input, amount, unit) {
+  const dateValue = parseDateInput(input);
+  return dateValue.subtract({ [unit + "s"]: amount });
+}
+export function set(input, values) {
+  let dateValue = parseDateInput(input);
+  if (values.year !== void 0) dateValue = dateValue.set({ year: values.year });
+  if (values.month !== void 0) dateValue = dateValue.set({ month: values.month });
+  if (values.day !== void 0) dateValue = dateValue.set({ day: values.day });
+  if (values.hour !== void 0 || values.minute !== void 0 || values.second !== void 0) {
+    if (!("hour" in dateValue)) {
+      dateValue = toCalendarDateTime(dateValue);
+    }
+    if (values.hour !== void 0)
+      dateValue = dateValue.set({
+        hour: values.hour
+      });
+    if (values.minute !== void 0)
+      dateValue = dateValue.set({
+        minute: values.minute
+      });
+    if (values.second !== void 0)
+      dateValue = dateValue.set({
+        second: values.second
+      });
+  }
+  return dateValue;
+}
+export function toDate(input, timeZone) {
+  if (input instanceof Date && !timeZone) {
+    return input;
+  }
+  const dateValue = parseDateInput(input);
+  const tz = timeZone ?? getLocalTimeZone();
+  return toCalendarDate(dateValue).toDate(tz);
+}
+export function format(input, formatString = "YYYY-MM-DD", locale = "en-US") {
+  const jsDate = toDate(input);
+  const pad = (num, length = 2) => String(num).padStart(length, "0");
+  const getMonthName = (monthIndex, short = false) => {
+    const date = new Date(2e3, monthIndex, 1);
+    return new Intl.DateTimeFormat(locale, {
+      month: short ? "short" : "long"
+    }).format(date);
+  };
+  const formatMap = {
+    short: "short",
+    long: "long",
+    narrow: "narrow"
+  };
+  const getWeekdayName = (dayIndex, format2) => {
+    const date = new Date(2e3, 0, 2 + dayIndex);
+    return new Intl.DateTimeFormat(locale, {
+      weekday: formatMap[format2]
+    }).format(date);
+  };
+  const year = jsDate.getFullYear();
+  const month = jsDate.getMonth() + 1;
+  const day = jsDate.getDate();
+  const weekday = jsDate.getDay();
+  const hour24 = jsDate.getHours();
+  const hour12 = hour24 % 12 || 12;
+  const minute = jsDate.getMinutes();
+  const second = jsDate.getSeconds();
+  const millisecond = jsDate.getMilliseconds();
+  const isPM = hour24 >= 12;
+  const tokens = {
+    // Year
+    YYYY: String(year),
+    YY: String(year).slice(-2),
+    // Month
+    MMMM: getMonthName(month - 1, false),
+    MMM: getMonthName(month - 1, true),
+    MM: pad(month),
+    M: String(month),
+    // Day
+    DD: pad(day),
+    D: String(day),
+    // Day of week
+    dddd: getWeekdayName(weekday, "long"),
+    ddd: getWeekdayName(weekday, "short"),
+    dd: getWeekdayName(weekday, "narrow"),
+    d: String(weekday),
+    // Hour (24-hour)
+    HH: pad(hour24),
+    H: String(hour24),
+    // Hour (12-hour)
+    hh: pad(hour12),
+    h: String(hour12),
+    // Minute
+    mm: pad(minute),
+    m: String(minute),
+    // Second
+    ss: pad(second),
+    s: String(second),
+    // Millisecond
+    SSS: pad(millisecond, 3),
+    // AM/PM
+    A: isPM ? "PM" : "AM",
+    a: isPM ? "pm" : "am"
+  };
+  const tokenPattern = Object.keys(tokens).sort((a, b) => b.length - a.length).map((token) => token.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|");
+  const regex = new RegExp(tokenPattern, "g");
+  const result = formatString.replace(regex, (match) => tokens[match]);
+  return result;
+}
+export function relative(input, locale = "en-US") {
+  const nowMs = (/* @__PURE__ */ new Date()).getTime();
+  const targetMs = toDate(input).getTime();
+  const diffMs = targetMs - nowMs;
+  const diffSec = Math.round(diffMs / 1e3);
+  const diffMin = Math.round(diffSec / 60);
+  const diffHour = Math.round(diffMin / 60);
+  const diffDay = Math.round(diffHour / 24);
+  const diffWeek = Math.round(diffDay / 7);
+  const diffMonth = Math.round(diffDay / 30);
+  const diffYear = Math.round(diffDay / 365);
+  const rtf = new Intl.RelativeTimeFormat(locale, { numeric: "auto" });
+  if (Math.abs(diffSec) < 60) return rtf.format(diffSec, "second");
+  if (Math.abs(diffMin) < 60) return rtf.format(diffMin, "minute");
+  if (Math.abs(diffHour) < 24) return rtf.format(diffHour, "hour");
+  if (Math.abs(diffDay) < 7) return rtf.format(diffDay, "day");
+  if (Math.abs(diffWeek) < 4) return rtf.format(diffWeek, "week");
+  if (Math.abs(diffMonth) < 12) return rtf.format(diffMonth, "month");
+  return rtf.format(diffYear, "year");
+}
+export function asCalendarDate(input) {
+  const dateValue = parseDateInput(input);
+  return toCalendarDate(dateValue);
+}
+export function asCalendarDateTime(input) {
+  const dateValue = parseDateInput(input);
+  if ("hour" in dateValue) return dateValue;
+  return toCalendarDateTime(dateValue);
+}
+export function asZonedDateTime(input, timeZone) {
+  const dateValue = parseDateInput(input);
+  const tz = timeZone ?? getLocalTimeZone();
+  if ("timeZone" in dateValue) return dateValue;
+  const dateTime = "hour" in dateValue ? dateValue : toCalendarDateTime(dateValue);
+  return parseZonedDateTime(`${dateTime.toString()}[${tz}]`);
+}
+export function isBefore(input, other) {
+  const dateValue = parseDateInput(input);
+  const otherValue = parseDateInput(other);
+  return dateValue.compare(otherValue) < 0;
+}
+export function isAfter(input, other) {
+  const dateValue = parseDateInput(input);
+  const otherValue = parseDateInput(other);
+  return dateValue.compare(otherValue) > 0;
+}
+export function isSame(input, other) {
+  const dateValue = parseDateInput(input);
+  const otherValue = parseDateInput(other);
+  return dateValue.compare(otherValue) === 0;
+}
+export function diff(input, other, unit = "millisecond") {
+  const date1Ms = toDate(input).getTime();
+  const date2Ms = toDate(other).getTime();
+  const diffMs = date1Ms - date2Ms;
+  switch (unit) {
+    case "year":
+      return diffMs / (1e3 * 60 * 60 * 24 * 365.25);
+    case "month":
+      return diffMs / (1e3 * 60 * 60 * 24 * 30.44);
+    // Average month length
+    case "week":
+      return diffMs / (1e3 * 60 * 60 * 24 * 7);
+    case "day":
+      return diffMs / (1e3 * 60 * 60 * 24);
+    case "hour":
+      return diffMs / (1e3 * 60 * 60);
+    case "minute":
+      return diffMs / (1e3 * 60);
+    case "second":
+      return diffMs / 1e3;
+    case "millisecond":
+      return diffMs;
+    default:
+      return diffMs;
+  }
+}
+export function isBetween(input, start, end, inclusive = true) {
+  const dateValue = parseDateInput(input);
+  const startValue = parseDateInput(start);
+  const endValue = parseDateInput(end);
+  if (inclusive) {
+    return dateValue.compare(startValue) >= 0 && dateValue.compare(endValue) <= 0;
+  } else {
+    return dateValue.compare(startValue) > 0 && dateValue.compare(endValue) < 0;
+  }
+}
+export function startOf(input, unit, locale = "en-US") {
+  const dateValue = parseDateInput(input);
+  const calDate = toCalendarDate(dateValue);
+  switch (unit) {
+    case "day":
+      return calDate;
+    case "week":
+      return startOfWeek(calDate, locale);
+    case "month":
+      return calDate.set({ day: 1 });
+    case "year":
+      return calDate.set({ month: 1, day: 1 });
+    default:
+      return calDate;
+  }
+}
+export function endOf(input, unit, locale = "en-US") {
+  const dateValue = parseDateInput(input);
+  const calDate = toCalendarDate(dateValue);
+  switch (unit) {
+    case "day":
+      return calDate;
+    case "week":
+      return endOfWeek(calDate, locale);
+    case "month": {
+      const nextMonth = calDate.add({ months: 1 }).set({ day: 1 });
+      return nextMonth.subtract({ days: 1 });
+    }
+    case "year":
+      return calDate.set({ month: 12, day: 31 });
+    default:
+      return calDate;
+  }
+}
+export function today(timeZone) {
+  const tz = timeZone ?? getLocalTimeZone();
+  return todayFromLib(tz);
+}
+export function now(timeZone) {
+  const tz = timeZone ?? getLocalTimeZone();
+  return nowFromLib(tz);
+}
+export function parse(dateString) {
+  return parseDate(dateString);
+}
+export {
+  isSameDay,
+  isSameMonth,
+  isSameYear,
+  isToday,
+  isWeekend,
+  getDayOfWeek,
+  getWeeksInMonth,
+  getLocalTimeZone
+};

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

@@ -3,10 +3,12 @@
  * Import from '#std' for tree-shakeable utilities
  *
  * @example
- * import { plur, dayjs } from '#std'
+ * import { plur, slugify, date } from '#std'
  *
  * const text = plur('item', count)
- * const date = dayjs().format('YYYY-MM-DD')
+ * const slug = slugify('Hello World')
+ * const nextMonth = date.add(date.today(), 1, 'month')
  */
 export { default as plur } from "plur";
-export { default as dayjs } from "dayjs/esm";
+export { default as slugify } from "@sindresorhus/slugify";
+export * as date from "./std/date.js";

package/dist/runtime/utils/std.js

@@ -1,2 +1,3 @@
 export { default as plur } from "plur";
-export { default as dayjs } from "dayjs/esm";
+export { default as slugify } from "@sindresorhus/slugify";
+export * as date from "./std/date.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nuxt-ui-elements",
-  "version": "0.1.16",
+  "version": "0.1.18",
   "description": "A collection of beautiful, animated UI components for Nuxt applications",
   "license": "MIT",
   "repository": "https://github.com/genu/nuxt-ui-elements.git",
@@ -25,8 +25,9 @@
     }
   },
   "dependencies": {
+    "@internationalized/date": "^3.10.1",
     "@nuxt/kit": "^4.2.2",
-    "dayjs": "^1.11.19",
+    "@sindresorhus/slugify": "^3.0.0",
     "plur": "^6.0.0",
     "scule": "^1.3.0",
     "tailwind-variants": "^3.2.2"
@@ -47,7 +48,7 @@
     "prettier": "^3.7.4",
     "typescript": "~5.9.3",
     "vitest": "^4.0.16",
-    "vue-tsc": "^3.2.1"
+    "vue-tsc": "^3.2.2"
   },
   "peerDependencies": {
     "@nuxt/ui": "^4.0.0"