@ciwergrp/nuxid 1.14.0 → 1.15.0

package/README.md

@@ -31,7 +31,7 @@ export default defineNuxtConfig({
   - `alias` (`Array<[from, to]>`)
 - **Validator helpers** (enabled by default): Element Plus friendly `createValidationRules` plus `ValidationRule` and `ValidationOptions` types. Auto-imported when enabled.
 - **Form composable** (enabled by default): `useHttp` wraps `$fetch`, handles `processing`, `errors`, `response`, and builds `FormData` automatically (or always when `alwaysFormData: true`). Auto-imported when enabled.
-- **Helper utilities** (enabled by default): array/object/number/string helpers with configurable factory (`number().abbreviate()`) or prefixed (`NumberAbbreviate()`) styles, locale lookups, and currency defaults.
+- **Helper utilities** (enabled by default): array/object/number/string/date helpers with configurable factory (`number().abbreviate()`) or prefixed (`NumberAbbreviate()`) styles, locale lookups, currency defaults, and timezone source configuration (`query`/`cookie`/`localStorage`/`static`).
 - **Cursor fetch composable** (enabled by default): `useCursorFetch` wraps `$fetch`, supports cursor pagination, polling, reactive params, custom fetchers, and configurable cursor/meta keys. Auto-imported when enabled.
 - **Pinia integration** (enabled by default): injects Pinia, auto-imports core helpers (`defineStore`, `storeToRefs`, etc.), and auto-imports stores from `stores` by default.
 - **Icon defaults** (disabled by default): installs `@nuxt/icon` with default component name `KIcon`, size `1.25em`, base class `align-middle inline-block text-current`, mode `svg`. Configure via `nuxid.icon.config`.
@@ -145,6 +145,12 @@ export default defineNuxtConfig({
         localeKey: 'lang',
         localeFallback: 'en',
         defaultCurrency: 'USD',
+        timezone: {
+          source: 'cookie',
+          key: 'tz',
+          static: 'UTC',
+          fallback: 'UTC',
+        },
       },
     },
     pinia: {

package/dist/module.d.mts

@@ -1,4 +1,5 @@
 import * as _nuxt_schema from '@nuxt/schema';
+import { TimezoneId } from '../dist/runtime/helper/date/timezones.js';
 export * from '../dist/runtime/form.js';
 export { default as useHttp } from '../dist/runtime/form.js';
 export { useBreadcrumbs, useTitle } from '../dist/runtime/page/index.js';
@@ -129,6 +130,29 @@ interface ElementPlusOptions {
 }
 type ElementPlusFeatureInput = boolean | Partial<ElementPlusOptions> | Record<string, any> | undefined;
 
+type HelperTimezoneSource = 'query' | 'cookie' | 'localStorage' | 'static';
+interface HelperTimezoneOptions {
+    /**
+     * Where timezone value should be read from
+     * @default 'cookie'
+     */
+    source?: HelperTimezoneSource;
+    /**
+     * Query/cookie/localStorage key name for timezone value
+     * @default 'tz'
+     */
+    key?: string;
+    /**
+     * Fixed timezone value when source is static
+     * @default 'UTC'
+     */
+    static?: TimezoneId;
+    /**
+     * Fallback timezone when source value is missing/invalid
+     * @default 'UTC'
+     */
+    fallback?: TimezoneId;
+}
 interface HelperOptions {
     /**
      * @default true
@@ -163,6 +187,26 @@ interface HelperOptions {
          * @default 'USD'
          */
         defaultCurrency?: string;
+        /**
+         * Timezone configuration for date helpers
+         */
+        timezone?: HelperTimezoneOptions;
+        /**
+         * @deprecated Use config.timezone.source
+         */
+        timezoneSource?: HelperTimezoneSource;
+        /**
+         * @deprecated Use config.timezone.key
+         */
+        timezoneKey?: string;
+        /**
+         * @deprecated Use config.timezone.static
+         */
+        timezoneStatic?: TimezoneId;
+        /**
+         * @deprecated Use config.timezone.fallback
+         */
+        timezoneFallback?: TimezoneId;
     };
 }
 type HelperFeatureInput = boolean | Partial<HelperOptions> | undefined;

package/dist/module.json

@@ -1,7 +1,7 @@
 {
   "name": "@ciwergrp/nuxid",
   "configKey": "nuxid",
-  "version": "1.14.0",
+  "version": "1.15.0",
   "builder": {
     "@nuxt/module-builder": "1.0.2",
     "unbuild": "3.6.1"

package/dist/module.mjs

@@ -182,7 +182,13 @@ const helperDefaults = {
     localeSource: "cookie",
     localeKey: "lang",
     localeFallback: "en",
-    defaultCurrency: "USD"
+    defaultCurrency: "USD",
+    timezone: {
+      source: "cookie",
+      key: "tz",
+      static: "UTC",
+      fallback: "UTC"
+    }
   }
 };
 function resolveHelperOptions(input) {
@@ -191,6 +197,11 @@ function resolveHelperOptions(input) {
   }
   const overrides = typeof input === "boolean" || input === void 0 ? {} : input;
   const config = overrides.config ?? {};
+  const timezoneConfig = config.timezone ?? {};
+  const timezoneSource = timezoneConfig.source ?? config.timezoneSource ?? helperDefaults.config.timezone.source;
+  const timezoneKey = timezoneConfig.key ?? config.timezoneKey ?? helperDefaults.config.timezone.key;
+  const timezoneStatic = timezoneConfig.static ?? config.timezoneStatic ?? helperDefaults.config.timezone.static;
+  const timezoneFallback = timezoneConfig.fallback ?? config.timezoneFallback ?? helperDefaults.config.timezone.fallback;
   return {
     enabled: overrides?.enabled ?? true,
     config: {
@@ -198,14 +209,21 @@ function resolveHelperOptions(input) {
       localeSource: config.localeSource ?? helperDefaults.config.localeSource,
       localeKey: config.localeKey ?? helperDefaults.config.localeKey,
       localeFallback: config.localeFallback ?? helperDefaults.config.localeFallback,
-      defaultCurrency: config.defaultCurrency ?? helperDefaults.config.defaultCurrency
+      defaultCurrency: config.defaultCurrency ?? helperDefaults.config.defaultCurrency,
+      timezone: {
+        source: timezoneSource,
+        key: timezoneKey,
+        static: timezoneStatic,
+        fallback: timezoneFallback
+      }
     }
   };
 }
-function registerHelperFeature(options, { from }) {
+function registerHelperFeature(options, { from, plugin }) {
   if (!options.enabled) {
     return;
   }
+  addPlugin(plugin);
   const style = options.config.style;
   if (style === "factory") {
     addImports({ name: "array", as: "array", from });
@@ -339,6 +357,8 @@ function registerHelperFeature(options, { from }) {
     "toRfc3339String",
     "toRfc7231String",
     "localDateToUTCISO",
+    "availableTimezones",
+    "currentTimezone",
     "dateParse",
     "parseISO",
     "addSecond",
@@ -648,8 +668,16 @@ const module$1 = defineNuxtModule({
       });
     }
     if (helperOptions.enabled) {
+      nuxt.options.runtimeConfig.public = nuxt.options.runtimeConfig.public || {};
+      nuxt.options.runtimeConfig.public.nuxid = {
+        ...nuxt.options.runtimeConfig.public.nuxid || {},
+        helper: {
+          config: helperOptions.config
+        }
+      };
       registerHelperFeature(helperOptions, {
-        from: resolver.resolve("./runtime/helper")
+        from: resolver.resolve("./runtime/helper"),
+        plugin: resolver.resolve("./runtime/helper/plugin")
       });
     }
     if (fetcherOptions.enabled) {

package/dist/runtime/helper/date/bounds.js

@@ -16,52 +16,52 @@ import {
   startOfWeek as startOfWeekBase,
   startOfYear as startOfYearBase
 } from "date-fns";
-import { toDate } from "./input.js";
+import { toCurrentTimezoneDate, toNativeDate } from "./context.js";
 export function startOfSecond(date) {
-  return startOfSecondBase(toDate(date));
+  return toNativeDate(startOfSecondBase(toCurrentTimezoneDate(date)));
 }
 export function endOfSecond(date) {
-  return endOfSecondBase(toDate(date));
+  return toNativeDate(endOfSecondBase(toCurrentTimezoneDate(date)));
 }
 export function startOfMinute(date) {
-  return startOfMinuteBase(toDate(date));
+  return toNativeDate(startOfMinuteBase(toCurrentTimezoneDate(date)));
 }
 export function endOfMinute(date) {
-  return endOfMinuteBase(toDate(date));
+  return toNativeDate(endOfMinuteBase(toCurrentTimezoneDate(date)));
 }
 export function startOfHour(date) {
-  return startOfHourBase(toDate(date));
+  return toNativeDate(startOfHourBase(toCurrentTimezoneDate(date)));
 }
 export function endOfHour(date) {
-  return endOfHourBase(toDate(date));
+  return toNativeDate(endOfHourBase(toCurrentTimezoneDate(date)));
 }
 export function startOfDay(date) {
-  return startOfDayBase(toDate(date));
+  return toNativeDate(startOfDayBase(toCurrentTimezoneDate(date)));
 }
 export function endOfDay(date) {
-  return endOfDayBase(toDate(date));
+  return toNativeDate(endOfDayBase(toCurrentTimezoneDate(date)));
 }
 export function startOfWeek(date) {
-  return startOfWeekBase(toDate(date));
+  return toNativeDate(startOfWeekBase(toCurrentTimezoneDate(date)));
 }
 export function endOfWeek(date) {
-  return endOfWeekBase(toDate(date));
+  return toNativeDate(endOfWeekBase(toCurrentTimezoneDate(date)));
 }
 export function startOfMonth(date) {
-  return startOfMonthBase(toDate(date));
+  return toNativeDate(startOfMonthBase(toCurrentTimezoneDate(date)));
 }
 export function endOfMonth(date) {
-  return endOfMonthBase(toDate(date));
+  return toNativeDate(endOfMonthBase(toCurrentTimezoneDate(date)));
 }
 export function startOfQuarter(date) {
-  return startOfQuarterBase(toDate(date));
+  return toNativeDate(startOfQuarterBase(toCurrentTimezoneDate(date)));
 }
 export function endOfQuarter(date) {
-  return endOfQuarterBase(toDate(date));
+  return toNativeDate(endOfQuarterBase(toCurrentTimezoneDate(date)));
 }
 export function startOfYear(date) {
-  return startOfYearBase(toDate(date));
+  return toNativeDate(startOfYearBase(toCurrentTimezoneDate(date)));
 }
 export function endOfYear(date) {
-  return endOfYearBase(toDate(date));
+  return toNativeDate(endOfYearBase(toCurrentTimezoneDate(date)));
 }

package/dist/runtime/helper/date/compare.js

@@ -20,6 +20,7 @@ import {
   isWeekend as isWeekendBase,
   isYesterday as isYesterdayBase
 } from "date-fns";
+import { toCurrentTimezoneDate } from "./context.js";
 import { toDate } from "./input.js";
 export function isBefore(date, dateToCompare) {
   return isBeforeBase(toDate(date), toDate(dateToCompare));
@@ -31,37 +32,37 @@ export function isEqual(date, dateToCompare) {
   return isEqualBase(toDate(date), toDate(dateToCompare));
 }
 export function isSameSecond(date, dateToCompare) {
-  return isSameSecondBase(toDate(date), toDate(dateToCompare));
+  return isSameSecondBase(toCurrentTimezoneDate(date), toCurrentTimezoneDate(dateToCompare));
 }
 export function isSameMinute(date, dateToCompare) {
-  return isSameMinuteBase(toDate(date), toDate(dateToCompare));
+  return isSameMinuteBase(toCurrentTimezoneDate(date), toCurrentTimezoneDate(dateToCompare));
 }
 export function isSameHour(date, dateToCompare) {
-  return isSameHourBase(toDate(date), toDate(dateToCompare));
+  return isSameHourBase(toCurrentTimezoneDate(date), toCurrentTimezoneDate(dateToCompare));
 }
 export function isSameDay(date, dateToCompare) {
-  return isSameDayBase(toDate(date), toDate(dateToCompare));
+  return isSameDayBase(toCurrentTimezoneDate(date), toCurrentTimezoneDate(dateToCompare));
 }
 export function isSameWeek(date, dateToCompare) {
-  return isSameWeekBase(toDate(date), toDate(dateToCompare));
+  return isSameWeekBase(toCurrentTimezoneDate(date), toCurrentTimezoneDate(dateToCompare));
 }
 export function isSameMonth(date, dateToCompare) {
-  return isSameMonthBase(toDate(date), toDate(dateToCompare));
+  return isSameMonthBase(toCurrentTimezoneDate(date), toCurrentTimezoneDate(dateToCompare));
 }
 export function isSameYear(date, dateToCompare) {
-  return isSameYearBase(toDate(date), toDate(dateToCompare));
+  return isSameYearBase(toCurrentTimezoneDate(date), toCurrentTimezoneDate(dateToCompare));
 }
 export function isToday(date) {
-  return isTodayBase(toDate(date));
+  return isTodayBase(toCurrentTimezoneDate(date));
 }
 export function isTomorrow(date) {
-  return isTomorrowBase(toDate(date));
+  return isTomorrowBase(toCurrentTimezoneDate(date));
 }
 export function isYesterday(date) {
-  return isYesterdayBase(toDate(date));
+  return isYesterdayBase(toCurrentTimezoneDate(date));
 }
 export function isWeekend(date) {
-  return isWeekendBase(toDate(date));
+  return isWeekendBase(toCurrentTimezoneDate(date));
 }
 export function isPast(date) {
   return isPastBase(toDate(date));
@@ -70,13 +71,13 @@ export function isFuture(date) {
   return isFutureBase(toDate(date));
 }
 export function isThisWeek(date) {
-  return isThisWeekBase(toDate(date));
+  return isThisWeekBase(toCurrentTimezoneDate(date));
 }
 export function isThisMonth(date) {
-  return isThisMonthBase(toDate(date));
+  return isThisMonthBase(toCurrentTimezoneDate(date));
 }
 export function isThisYear(date) {
-  return isThisYearBase(toDate(date));
+  return isThisYearBase(toCurrentTimezoneDate(date));
 }
 export function isValid(date) {
   return isValidBase(toDate(date));

package/dist/runtime/helper/date/context.d.ts

@@ -0,0 +1,5 @@
+import type { DateInput } from './input.js';
+import type { TimezoneId } from './timezones.js';
+export declare function toTimezoneDate(value: DateInput | Date, timezone: TimezoneId): import("@date-fns/tz").TZDate;
+export declare function toCurrentTimezoneDate(value: DateInput | Date): import("@date-fns/tz").TZDate;
+export declare function toNativeDate(value: Date): Date;

package/dist/runtime/helper/date/context.js

@@ -0,0 +1,13 @@
+import { TZDateMini } from "@date-fns/tz";
+import { toDate } from "./input.js";
+import { currentTimezone } from "./timezone.js";
+export function toTimezoneDate(value, timezone) {
+  const resolvedDate = toDate(value);
+  return new TZDateMini(resolvedDate.getTime(), timezone);
+}
+export function toCurrentTimezoneDate(value) {
+  return toTimezoneDate(value, currentTimezone().value);
+}
+export function toNativeDate(value) {
+  return new Date(value.getTime());
+}

package/dist/runtime/helper/date/format.js

@@ -6,41 +6,41 @@ import {
   formatRFC3339 as formatRFC3339Date,
   formatRFC7231 as formatRFC7231Date
 } from "date-fns";
-import { toDate } from "./input.js";
+import { toCurrentTimezoneDate } from "./context.js";
 export function format(date, formatString, options) {
-  return formatDate(toDate(date), formatString, options);
+  return formatDate(toCurrentTimezoneDate(date), formatString, options);
 }
 export function formatISO(date, options) {
-  return formatISODate(toDate(date), options);
+  return formatISODate(toCurrentTimezoneDate(date), options);
 }
 export function formatRFC3339(date, options) {
-  return formatRFC3339Date(toDate(date), options);
+  return formatRFC3339Date(toCurrentTimezoneDate(date), options);
 }
 export function formatRFC7231(date) {
-  return formatRFC7231Date(toDate(date));
+  return formatRFC7231Date(toCurrentTimezoneDate(date));
 }
 export function fromNow(date, options = {}) {
-  return formatDistanceToNow(toDate(date), { addSuffix: true, ...options });
+  return formatDistanceToNow(toCurrentTimezoneDate(date), { addSuffix: true, ...options });
 }
 export function diffForHumans(date, baseDate, options = {}) {
-  const resolvedBase = baseDate ? toDate(baseDate) : /* @__PURE__ */ new Date();
-  return formatDistance(toDate(date), resolvedBase, { addSuffix: true, ...options });
+  const resolvedBase = baseDate ? toCurrentTimezoneDate(baseDate) : toCurrentTimezoneDate(/* @__PURE__ */ new Date());
+  return formatDistance(toCurrentTimezoneDate(date), resolvedBase, { addSuffix: true, ...options });
 }
 export function toDateString(date) {
-  return formatDate(toDate(date), "yyyy-MM-dd");
+  return formatDate(toCurrentTimezoneDate(date), "yyyy-MM-dd");
 }
 export function toTimeString(date) {
-  return formatDate(toDate(date), "HH:mm:ss");
+  return formatDate(toCurrentTimezoneDate(date), "HH:mm:ss");
 }
 export function toDateTimeString(date) {
-  return formatDate(toDate(date), "yyyy-MM-dd HH:mm:ss");
+  return formatDate(toCurrentTimezoneDate(date), "yyyy-MM-dd HH:mm:ss");
 }
 export function toIsoString(date) {
-  return formatISODate(toDate(date));
+  return formatISODate(toCurrentTimezoneDate(date));
 }
 export function toRfc3339String(date) {
-  return formatRFC3339Date(toDate(date));
+  return formatRFC3339Date(toCurrentTimezoneDate(date));
 }
 export function toRfc7231String(date) {
-  return formatRFC7231Date(toDate(date));
+  return formatRFC7231Date(toCurrentTimezoneDate(date));
 }

package/dist/runtime/helper/date/index.d.ts

@@ -6,15 +6,18 @@ import { addDay, addDays, addHour, addHours, addMinute, addMinutes, addMonth, ad
 import { endOfDay, endOfHour, endOfMinute, endOfMonth, endOfQuarter, endOfSecond, endOfWeek, endOfYear, startOfDay, startOfHour, startOfMinute, startOfMonth, startOfQuarter, startOfSecond, startOfWeek, startOfYear } from './bounds.js';
 import { diffInDays, diffInHours, diffInMinutes, diffInMonths, diffInSeconds, diffInWeeks, diffInYears } from './diff.js';
 import { isAfter, isBefore, isEqual, isFuture, isPast, isSameDay, isSameHour, isSameMinute, isSameMonth, isSameSecond, isSameWeek, isSameYear, isThisMonth, isThisWeek, isThisYear, isToday, isTomorrow, isValid, isWeekend, isYesterday } from './compare.js';
-import { localDateToUTCISO, type LocalDateToUTCISOOptions } from './utc.js';
+import { availableTimezones, currentTimezone } from './timezone.js';
+import type { TimezoneId } from './timezones.js';
+import { localDateToUTCISO } from './utc.js';
+import type { LocalDateToUTCISOOptions } from './utc.js';
 export type { DateFormatPreset } from './format.js';
-export type { LocalDateToUTCISOOptions };
-export interface DateHelper {
+export type { LocalDateToUTCISOOptions, TimezoneId };
+declare function createDateHelper(): {
     toDate: typeof toDate;
     toUnix: typeof toUnix;
     toMillis: typeof toMillis;
     fromUnix: typeof fromUnix;
-    fromTimestamp: typeof fromTimestamp;
+    fromTimestamp: typeof fromUnix;
     now: typeof now;
     today: typeof today;
     tomorrow: typeof tomorrow;
@@ -32,6 +35,8 @@ export interface DateHelper {
     toRfc3339String: typeof toRfc3339String;
     toRfc7231String: typeof toRfc7231String;
     localDateToUTCISO: typeof localDateToUTCISO;
+    availableTimezones: typeof availableTimezones;
+    currentTimezone: typeof currentTimezone;
     parse: typeof parse;
     parseISO: typeof parseISO;
     addSecond: typeof addSecond;
@@ -105,6 +110,7 @@ export interface DateHelper {
     isThisMonth: typeof isThisMonth;
     isThisYear: typeof isThisYear;
     isValid: typeof isValid;
-}
+};
+export type DateHelper = ReturnType<typeof createDateHelper>;
 export declare function dt(): DateHelper;
-export { type DateInput, toDate, toUnix, toMillis, fromUnix, fromTimestamp, now, today, tomorrow, yesterday, format as dateFormat, formatISO, formatRFC3339, formatRFC7231, fromNow, diffForHumans, toDateString, toTimeString, toDateTimeString, toIsoString, toRfc3339String, toRfc7231String, localDateToUTCISO, parse as dateParse, parseISO, addSecond, addSeconds, addMinute, addMinutes, addHour, addHours, addDay, addDays, addWeek, addWeeks, addMonth, addMonths, addYear, addYears, subSecond, subSeconds, subMinute, subMinutes, subHour, subHours, subDay, subDays, subWeek, subWeeks, subMonth, subMonths, subYear, subYears, startOfSecond, endOfSecond, startOfMinute, endOfMinute, startOfHour, endOfHour, startOfDay, endOfDay, startOfWeek, endOfWeek, startOfMonth, endOfMonth, startOfQuarter, endOfQuarter, startOfYear, endOfYear, diffInSeconds, diffInMinutes, diffInHours, diffInDays, diffInWeeks, diffInMonths, diffInYears, isBefore, isAfter, isEqual, isSameSecond, isSameMinute, isSameHour, isSameDay, isSameWeek, isSameMonth, isSameYear, isToday, isTomorrow, isYesterday, isWeekend, isPast, isFuture, isThisWeek, isThisMonth, isThisYear, isValid, };
+export { type DateInput, toDate, toUnix, toMillis, fromUnix, fromTimestamp, now, today, tomorrow, yesterday, format as dateFormat, formatISO, formatRFC3339, formatRFC7231, fromNow, diffForHumans, toDateString, toTimeString, toDateTimeString, toIsoString, toRfc3339String, toRfc7231String, localDateToUTCISO, availableTimezones, currentTimezone, parse as dateParse, parseISO, addSecond, addSeconds, addMinute, addMinutes, addHour, addHours, addDay, addDays, addWeek, addWeeks, addMonth, addMonths, addYear, addYears, subSecond, subSeconds, subMinute, subMinutes, subHour, subHours, subDay, subDays, subWeek, subWeeks, subMonth, subMonths, subYear, subYears, startOfSecond, endOfSecond, startOfMinute, endOfMinute, startOfHour, endOfHour, startOfDay, endOfDay, startOfWeek, endOfWeek, startOfMonth, endOfMonth, startOfQuarter, endOfQuarter, startOfYear, endOfYear, diffInSeconds, diffInMinutes, diffInHours, diffInDays, diffInWeeks, diffInMonths, diffInYears, isBefore, isAfter, isEqual, isSameSecond, isSameMinute, isSameHour, isSameDay, isSameWeek, isSameMonth, isSameYear, isToday, isTomorrow, isYesterday, isWeekend, isPast, isFuture, isThisWeek, isThisMonth, isThisYear, isValid, };

package/dist/runtime/helper/date/index.js

@@ -94,8 +94,9 @@ import {
   isWeekend,
   isYesterday
 } from "./compare.js";
+import { availableTimezones, currentTimezone } from "./timezone.js";
 import { localDateToUTCISO } from "./utc.js";
-export function dt() {
+function createDateHelper() {
   return {
     toDate,
     toUnix,
@@ -119,6 +120,8 @@ export function dt() {
     toRfc3339String,
     toRfc7231String,
     localDateToUTCISO,
+    availableTimezones,
+    currentTimezone,
     parse,
     parseISO,
     addSecond,
@@ -194,6 +197,9 @@ export function dt() {
     isValid
   };
 }
+export function dt() {
+  return createDateHelper();
+}
 export {
   toDate,
   toUnix,
@@ -217,6 +223,8 @@ export {
   toRfc3339String,
   toRfc7231String,
   localDateToUTCISO,
+  availableTimezones,
+  currentTimezone,
   parse as dateParse,
   parseISO,
   addSecond,

package/dist/runtime/helper/date/input.js

@@ -1,5 +1,7 @@
 import { parseISO } from "date-fns";
 const numericPattern = /^-?\d+$/;
+const dateOnlyPattern = /^\d{4}-\d{2}-\d{2}$/;
+const dateTimeNoZonePattern = /^\d{4}-\d{2}-\d{2}[ T]\d{2}:\d{2}(?::\d{2}(?:\.\d{1,3})?)?$/;
 export function toDate(value) {
   if (value instanceof Date) {
     return new Date(value.getTime());
@@ -19,6 +21,12 @@ export function toDate(value) {
     const isMilliseconds = trimmed.length >= 13;
     return new Date(isMilliseconds ? numeric : numeric * 1e3);
   }
+  if (dateOnlyPattern.test(trimmed)) {
+    return /* @__PURE__ */ new Date(`${trimmed}T00:00:00.000Z`);
+  }
+  if (dateTimeNoZonePattern.test(trimmed)) {
+    return /* @__PURE__ */ new Date(trimmed.replace(" ", "T") + "Z");
+  }
   const isoDate = parseISO(trimmed);
   if (!Number.isNaN(isoDate.getTime())) {
     return isoDate;

package/dist/runtime/helper/date/now.js

@@ -1,13 +1,14 @@
-import { startOfToday, startOfTomorrow, startOfYesterday } from "date-fns";
+import { addDays, startOfDay, subDays } from "date-fns";
+import { toCurrentTimezoneDate, toNativeDate } from "./context.js";
 export function now() {
   return /* @__PURE__ */ new Date();
 }
 export function today() {
-  return startOfToday();
+  return toNativeDate(startOfDay(toCurrentTimezoneDate(/* @__PURE__ */ new Date())));
 }
 export function tomorrow() {
-  return startOfTomorrow();
+  return toNativeDate(startOfDay(addDays(toCurrentTimezoneDate(/* @__PURE__ */ new Date()), 1)));
 }
 export function yesterday() {
-  return startOfYesterday();
+  return toNativeDate(startOfDay(subDays(toCurrentTimezoneDate(/* @__PURE__ */ new Date()), 1)));
 }

package/dist/runtime/helper/date/parse.js

@@ -1,8 +1,14 @@
 import { parse as parseDate, parseISO as parseISODate } from "date-fns";
 import { toDate } from "./input.js";
+import { toNativeDate, toTimezoneDate } from "./context.js";
 export function parse(value, formatString, baseDate = /* @__PURE__ */ new Date(), options) {
-  return parseDate(value, formatString, toDate(baseDate), options);
+  const parsedDate = parseDate(value, formatString, toTimezoneDate(baseDate, "UTC"), options);
+  return toNativeDate(parsedDate);
 }
 export function parseISO(value) {
-  return parseISODate(value);
+  const parsedDate = parseISODate(value);
+  if (!Number.isNaN(parsedDate.getTime())) {
+    return toDate(value);
+  }
+  return parsedDate;
 }

package/dist/runtime/helper/date/shift.js

@@ -14,87 +14,87 @@ import {
   subWeeks as subWeeksBase,
   subYears as subYearsBase
 } from "date-fns";
-import { toDate } from "./input.js";
+import { toCurrentTimezoneDate, toNativeDate } from "./context.js";
 export function addSeconds(date, amount) {
-  return addSecondsBase(toDate(date), amount);
+  return toNativeDate(addSecondsBase(toCurrentTimezoneDate(date), amount));
 }
 export function addSecond(date) {
   return addSeconds(date, 1);
 }
 export function addMinutes(date, amount) {
-  return addMinutesBase(toDate(date), amount);
+  return toNativeDate(addMinutesBase(toCurrentTimezoneDate(date), amount));
 }
 export function addMinute(date) {
   return addMinutes(date, 1);
 }
 export function addHours(date, amount) {
-  return addHoursBase(toDate(date), amount);
+  return toNativeDate(addHoursBase(toCurrentTimezoneDate(date), amount));
 }
 export function addHour(date) {
   return addHours(date, 1);
 }
 export function addDays(date, amount) {
-  return addDaysBase(toDate(date), amount);
+  return toNativeDate(addDaysBase(toCurrentTimezoneDate(date), amount));
 }
 export function addDay(date) {
   return addDays(date, 1);
 }
 export function addWeeks(date, amount) {
-  return addWeeksBase(toDate(date), amount);
+  return toNativeDate(addWeeksBase(toCurrentTimezoneDate(date), amount));
 }
 export function addWeek(date) {
   return addWeeks(date, 1);
 }
 export function addMonths(date, amount) {
-  return addMonthsBase(toDate(date), amount);
+  return toNativeDate(addMonthsBase(toCurrentTimezoneDate(date), amount));
 }
 export function addMonth(date) {
   return addMonths(date, 1);
 }
 export function addYears(date, amount) {
-  return addYearsBase(toDate(date), amount);
+  return toNativeDate(addYearsBase(toCurrentTimezoneDate(date), amount));
 }
 export function addYear(date) {
   return addYears(date, 1);
 }
 export function subSeconds(date, amount) {
-  return subSecondsBase(toDate(date), amount);
+  return toNativeDate(subSecondsBase(toCurrentTimezoneDate(date), amount));
 }
 export function subSecond(date) {
   return subSeconds(date, 1);
 }
 export function subMinutes(date, amount) {
-  return subMinutesBase(toDate(date), amount);
+  return toNativeDate(subMinutesBase(toCurrentTimezoneDate(date), amount));
 }
 export function subMinute(date) {
   return subMinutes(date, 1);
 }
 export function subHours(date, amount) {
-  return subHoursBase(toDate(date), amount);
+  return toNativeDate(subHoursBase(toCurrentTimezoneDate(date), amount));
 }
 export function subHour(date) {
   return subHours(date, 1);
 }
 export function subDays(date, amount) {
-  return subDaysBase(toDate(date), amount);
+  return toNativeDate(subDaysBase(toCurrentTimezoneDate(date), amount));
 }
 export function subDay(date) {
   return subDays(date, 1);
 }
 export function subWeeks(date, amount) {
-  return subWeeksBase(toDate(date), amount);
+  return toNativeDate(subWeeksBase(toCurrentTimezoneDate(date), amount));
 }
 export function subWeek(date) {
   return subWeeks(date, 1);
 }
 export function subMonths(date, amount) {
-  return subMonthsBase(toDate(date), amount);
+  return toNativeDate(subMonthsBase(toCurrentTimezoneDate(date), amount));
 }
 export function subMonth(date) {
   return subMonths(date, 1);
 }
 export function subYears(date, amount) {
-  return subYearsBase(toDate(date), amount);
+  return toNativeDate(subYearsBase(toCurrentTimezoneDate(date), amount));
 }
 export function subYear(date) {
   return subYears(date, 1);

package/dist/runtime/helper/date/timezone.d.ts

@@ -0,0 +1,7 @@
+import type { Ref } from 'vue';
+import { type TimezoneId } from './timezones.js';
+export declare function availableTimezones(): TimezoneId[];
+export declare function currentTimezone(): Readonly<Ref<TimezoneId>>;
+export declare function isTimezoneId(value: string): value is TimezoneId;
+export declare function normalizeTimezone(rawValue?: string | null): TimezoneId | undefined;
+export declare function setCurrentTimezone(value: string | undefined, fallback?: TimezoneId): TimezoneId;