@arkv/temporal 0.2.0

package/dist/esm/locale.js

@@ -0,0 +1,66 @@
+const en = {
+    name: 'en',
+    months: [
+        'January',
+        'February',
+        'March',
+        'April',
+        'May',
+        'June',
+        'July',
+        'August',
+        'September',
+        'October',
+        'November',
+        'December',
+    ],
+    monthsShort: [
+        'Jan',
+        'Feb',
+        'Mar',
+        'Apr',
+        'May',
+        'Jun',
+        'Jul',
+        'Aug',
+        'Sep',
+        'Oct',
+        'Nov',
+        'Dec',
+    ],
+    weekdays: [
+        'Sunday',
+        'Monday',
+        'Tuesday',
+        'Wednesday',
+        'Thursday',
+        'Friday',
+        'Saturday',
+    ],
+    weekdaysShort: [
+        'Sun',
+        'Mon',
+        'Tue',
+        'Wed',
+        'Thu',
+        'Fri',
+        'Sat',
+    ],
+    weekdaysMin: ['Su', 'Mo', 'Tu', 'We', 'Th', 'Fr', 'Sa'],
+    weekStart: 0,
+};
+const Ls = { en };
+let globalLocale = 'en';
+export function getLocaleObj(name) {
+    return Ls[name] ?? en;
+}
+export function getGlobalLocale() {
+    return globalLocale;
+}
+export function setGlobalLocale(name) {
+    globalLocale = name;
+}
+export function registerLocale(locale) {
+    Ls[locale.name] = locale;
+}
+export { Ls };

package/dist/esm/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/dist/esm/parse.js

@@ -0,0 +1,43 @@
+const DATE_ONLY = /^\d{4}-\d{2}-\d{2}$/;
+const HAS_OFFSET = /Z|[+-]\d{2}:\d{2}/;
+const HAS_ANNOTATION = /\[/;
+function parseString(s, tz) {
+    try {
+        if (HAS_ANNOTATION.test(s)) {
+            return Temporal.ZonedDateTime.from(s);
+        }
+        if (HAS_OFFSET.test(s)) {
+            return Temporal.Instant.from(s).toZonedDateTimeISO(tz);
+        }
+        if (DATE_ONLY.test(s)) {
+            return Temporal.PlainDate.from(s).toZonedDateTime(tz);
+        }
+        return Temporal.PlainDateTime.from(s).toZonedDateTime(tz);
+    }
+    catch {
+        return null;
+    }
+}
+function isTDayjsLike(d) {
+    return d !== null && typeof d === 'object' && '$zdt' in d;
+}
+export function parseInput(date, tz) {
+    if (date === null)
+        return null;
+    if (date === undefined) {
+        return Temporal.Now.zonedDateTimeISO(tz);
+    }
+    if (isTDayjsLike(date)) {
+        return date.$zdt;
+    }
+    if (typeof date === 'number') {
+        return Temporal.Instant.fromEpochMilliseconds(date).toZonedDateTimeISO(tz);
+    }
+    if (date instanceof Date) {
+        return Temporal.Instant.fromEpochMilliseconds(date.getTime()).toZonedDateTimeISO(tz);
+    }
+    if (typeof date === 'string') {
+        return parseString(date, tz);
+    }
+    return null;
+}

package/dist/esm/start-end.js

@@ -0,0 +1,107 @@
+const ZERO_TIME = {
+    hour: 0,
+    minute: 0,
+    second: 0,
+    millisecond: 0,
+    microsecond: 0,
+    nanosecond: 0,
+};
+const MAX_TIME = {
+    hour: 23,
+    minute: 59,
+    second: 59,
+    millisecond: 999,
+    microsecond: 999,
+    nanosecond: 999,
+};
+function startWeek(zdt, weekStart) {
+    // dayOfWeek: 1=Mon...7=Sun → convert to 0=Sun..6=Sat
+    const dow = zdt.dayOfWeek % 7;
+    const diff = (dow - weekStart + 7) % 7;
+    return zdt.subtract({ days: diff }).with(ZERO_TIME);
+}
+function endWeek(zdt, weekStart) {
+    const dow = zdt.dayOfWeek % 7;
+    const diff = (dow - weekStart + 7) % 7;
+    return zdt
+        .subtract({ days: diff })
+        .add({ days: 6 })
+        .with(MAX_TIME);
+}
+export function startOfHelper(zdt, unit, locale) {
+    const weekStart = locale.weekStart ?? 0;
+    switch (unit) {
+        case 'year':
+            return zdt.with({ month: 1, day: 1, ...ZERO_TIME });
+        case 'month':
+            return zdt.with({ day: 1, ...ZERO_TIME });
+        case 'week':
+            return startWeek(zdt, weekStart);
+        case 'day':
+        case 'date':
+            return zdt.with(ZERO_TIME);
+        case 'hour':
+            return zdt.with({
+                minute: 0,
+                second: 0,
+                millisecond: 0,
+                microsecond: 0,
+                nanosecond: 0,
+            });
+        case 'minute':
+            return zdt.with({
+                second: 0,
+                millisecond: 0,
+                microsecond: 0,
+                nanosecond: 0,
+            });
+        case 'second':
+            return zdt.with({
+                millisecond: 0,
+                microsecond: 0,
+                nanosecond: 0,
+            });
+        default:
+            return zdt;
+    }
+}
+export function endOfHelper(zdt, unit, locale) {
+    const weekStart = locale.weekStart ?? 0;
+    switch (unit) {
+        case 'year':
+            return zdt.with({ month: 12, day: 31, ...MAX_TIME });
+        case 'month':
+            return zdt.with({
+                day: zdt.daysInMonth,
+                ...MAX_TIME,
+            });
+        case 'week':
+            return endWeek(zdt, weekStart);
+        case 'day':
+        case 'date':
+            return zdt.with(MAX_TIME);
+        case 'hour':
+            return zdt.with({
+                minute: 59,
+                second: 59,
+                millisecond: 999,
+                microsecond: 999,
+                nanosecond: 999,
+            });
+        case 'minute':
+            return zdt.with({
+                second: 59,
+                millisecond: 999,
+                microsecond: 999,
+                nanosecond: 999,
+            });
+        case 'second':
+            return zdt.with({
+                millisecond: 999,
+                microsecond: 999,
+                nanosecond: 999,
+            });
+        default:
+            return zdt;
+    }
+}

package/dist/esm/types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/units.js

@@ -0,0 +1,52 @@
+const UNIT_MAP = {
+    y: 'year',
+    yr: 'year',
+    year: 'year',
+    years: 'year',
+    M: 'month',
+    month: 'month',
+    months: 'month',
+    Q: 'quarter',
+    quarter: 'quarter',
+    quarters: 'quarter',
+    w: 'week',
+    week: 'week',
+    weeks: 'week',
+    d: 'day',
+    day: 'day',
+    days: 'day',
+    D: 'date',
+    date: 'date',
+    dates: 'date',
+    h: 'hour',
+    hour: 'hour',
+    hours: 'hour',
+    m: 'minute',
+    min: 'minute',
+    minute: 'minute',
+    minutes: 'minute',
+    s: 'second',
+    sec: 'second',
+    second: 'second',
+    seconds: 'second',
+    ms: 'millisecond',
+    millisecond: 'millisecond',
+    milliseconds: 'millisecond',
+};
+export function normalizeUnit(u) {
+    return (UNIT_MAP[u] ??
+        UNIT_MAP[u.toLowerCase()] ??
+        'millisecond');
+}
+export const DURATION_KEY = {
+    year: 'years',
+    month: 'months',
+    quarter: null,
+    week: 'weeks',
+    day: 'days',
+    date: 'days',
+    hour: 'hours',
+    minute: 'minutes',
+    second: 'seconds',
+    millisecond: 'milliseconds',
+};

package/dist/types/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const FORMAT_DEFAULT = "YYYY-MM-DDTHH:mm:ssZ";
+export declare const INVALID_DATE = "Invalid Date";
+export declare const REGEX_FORMAT: RegExp;

package/dist/types/dayjs.d.ts

@@ -0,0 +1,61 @@
+import { type ILocale } from './locale.js';
+import type { ConfigType, ManipulateType, OpUnitType, QUnitType, UnitType } from './types.js';
+interface InternalConfig {
+    date?: ConfigType;
+    zdt?: Temporal.ZonedDateTime | null;
+    locale?: string;
+    tz?: string;
+}
+export declare const DEFAULT_TZ: string;
+export declare class TDayjs {
+    readonly $zdt: Temporal.ZonedDateTime | null;
+    readonly $L: string;
+    readonly $tz: string;
+    constructor(cfg: InternalConfig);
+    private _clone;
+    isValid(): this is this & {
+        $zdt: Temporal.ZonedDateTime;
+    };
+    clone(): TDayjs;
+    year(): number;
+    year(value: number): TDayjs;
+    month(): number;
+    month(value: number): TDayjs;
+    date(): number;
+    date(value: number): TDayjs;
+    day(): number;
+    day(value: number): TDayjs;
+    hour(): number;
+    hour(value: number): TDayjs;
+    minute(): number;
+    minute(value: number): TDayjs;
+    second(): number;
+    second(value: number): TDayjs;
+    millisecond(): number;
+    millisecond(value: number): TDayjs;
+    get(unit: UnitType): number;
+    private _getByUnit;
+    set(unit: UnitType, value: number): TDayjs;
+    private _setByUnit;
+    add(value: number, unit?: ManipulateType): TDayjs;
+    subtract(value: number, unit?: ManipulateType): TDayjs;
+    startOf(unit: OpUnitType): TDayjs;
+    endOf(unit: OpUnitType): TDayjs;
+    private _toZdt;
+    isBefore(date?: ConfigType, unit?: OpUnitType): boolean;
+    isAfter(date?: ConfigType, unit?: OpUnitType): boolean;
+    isSame(date?: ConfigType, unit?: OpUnitType): boolean;
+    format(template?: string): string;
+    diff(date?: ConfigType, unit?: QUnitType | OpUnitType, float?: boolean): number;
+    valueOf(): number;
+    unix(): number;
+    daysInMonth(): number;
+    utcOffset(): number;
+    toDate(): Date;
+    toISOString(): string;
+    toJSON(): string | null;
+    toString(): string;
+    locale(): string;
+    locale(preset: string | ILocale, object?: Partial<ILocale>): TDayjs;
+}
+export {};

package/dist/types/diff.d.ts

@@ -0,0 +1,2 @@
+import type { NormalizedUnit } from './units.js';
+export declare function diffHelper(from: Temporal.ZonedDateTime, to: Temporal.ZonedDateTime, unit: NormalizedUnit, float: boolean): number;

package/dist/types/format.d.ts

@@ -0,0 +1,2 @@
+import type { ILocale } from './locale.js';
+export declare function formatDate(zdt: Temporal.ZonedDateTime, template: string, locale: ILocale): string;

package/dist/types/index.d.ts

@@ -0,0 +1,16 @@
+import 'temporal-polyfill/global';
+import { TDayjs } from './dayjs.js';
+import { type ILocale } from './locale.js';
+import type { ConfigType } from './types.js';
+export { TDayjs } from './dayjs.js';
+export type { ILocale } from './locale.js';
+export type { ConfigType, ManipulateType, OpUnitType, QUnitType, UnitType, UnitTypeLong, UnitTypeLongPlural, UnitTypeShort, } from './types.js';
+type PluginFunc<T = unknown> = (option: T, c: typeof TDayjs, d: typeof tdayjs) => void;
+declare function tdayjs(date?: ConfigType): TDayjs;
+declare namespace tdayjs {
+    var extend: <T>(plugin: PluginFunc<T>, option?: T) => typeof tdayjs;
+    var isDayjs: (d: unknown) => d is TDayjs;
+    var unix: (t: number) => TDayjs;
+    var locale: (preset?: string | ILocale, object?: Partial<ILocale>) => string;
+}
+export default tdayjs;

package/dist/types/locale.d.ts

@@ -0,0 +1,15 @@
+export interface ILocale {
+    name: string;
+    months: string[];
+    monthsShort: string[];
+    weekdays: string[];
+    weekdaysShort: string[];
+    weekdaysMin: string[];
+    weekStart: number;
+}
+declare const Ls: Record<string, ILocale>;
+export declare function getLocaleObj(name: string): ILocale;
+export declare function getGlobalLocale(): string;
+export declare function setGlobalLocale(name: string): void;
+export declare function registerLocale(locale: ILocale): void;
+export { Ls };

package/dist/types/parse.d.ts

@@ -0,0 +1,2 @@
+import type { ConfigType } from './types.js';
+export declare function parseInput(date: ConfigType, tz: string): Temporal.ZonedDateTime | null;

package/dist/types/start-end.d.ts

@@ -0,0 +1,4 @@
+import type { ILocale } from './locale.js';
+import type { NormalizedUnit } from './units.js';
+export declare function startOfHelper(zdt: Temporal.ZonedDateTime, unit: NormalizedUnit, locale: ILocale): Temporal.ZonedDateTime;
+export declare function endOfHelper(zdt: Temporal.ZonedDateTime, unit: NormalizedUnit, locale: ILocale): Temporal.ZonedDateTime;

package/dist/types/types.d.ts

@@ -0,0 +1,12 @@
+export interface TDayjsLike {
+    readonly $zdt: Temporal.ZonedDateTime | null;
+    readonly $L: string;
+}
+export type ConfigType = string | number | Date | TDayjsLike | null | undefined;
+export type UnitTypeShort = 'd' | 'D' | 'M' | 'y' | 'h' | 'm' | 's' | 'ms';
+export type UnitTypeLong = 'millisecond' | 'second' | 'minute' | 'hour' | 'day' | 'month' | 'year' | 'date';
+export type UnitTypeLongPlural = 'milliseconds' | 'seconds' | 'minutes' | 'hours' | 'days' | 'months' | 'years' | 'dates';
+export type UnitType = UnitTypeLong | UnitTypeLongPlural | UnitTypeShort;
+export type OpUnitType = UnitType | 'week' | 'weeks' | 'w';
+export type QUnitType = UnitType | 'quarter' | 'quarters' | 'Q';
+export type ManipulateType = Exclude<OpUnitType, 'date' | 'dates'> | 'quarter' | 'quarters' | 'Q';

package/dist/types/units.d.ts

@@ -0,0 +1,4 @@
+export type NormalizedUnit = 'year' | 'month' | 'quarter' | 'week' | 'day' | 'date' | 'hour' | 'minute' | 'second' | 'millisecond';
+export type DurationKey = 'years' | 'months' | 'weeks' | 'days' | 'hours' | 'minutes' | 'seconds' | 'milliseconds';
+export declare function normalizeUnit(u: string): NormalizedUnit;
+export declare const DURATION_KEY: Record<NormalizedUnit, DurationKey | null>;

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@arkv/temporal",
+  "version": "0.2.0",
+  "description": "Drop-in Day.js-compatible API powered by the native Temporal API. Same chainable interface, zero timezone bugs.",
+  "main": "dist/cjs/index.js",
+  "module": "dist/esm/index.js",
+  "types": "dist/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.js"
+    }
+  },
+  "files": [
+    "LICENSE",
+    "README.md",
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "temporal",
+    "dayjs",
+    "date",
+    "time",
+    "timezone",
+    "typescript",
+    "javascript",
+    "node",
+    "browser"
+  ],
+  "scripts": {
+    "prebuild": "rm -rf dist",
+    "build:esm": "tsc -p tsconfig.build.esm.json",
+    "build:cjs": "tsc -p tsconfig.build.cjs.json",
+    "build:types": "tsc -p tsconfig.build.types.json",
+    "build": "bun run --parallel build:esm build:cjs build:types",
+    "postbuild": "echo '{\"type\":\"commonjs\"}' > dist/cjs/package.json && echo '{\"type\":\"module\"}' > dist/esm/package.json",
+    "test": "bun test --bail",
+    "test:cov": "bun test --coverage",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "temporal-polyfill": "0.3.0"
+  },
+  "author": {
+    "name": "Petar Zarkov",
+    "email": "pzarko1@gmail.com",
+    "url": "https://github.com/petarzarkov"
+  },
+  "license": "MIT",
+  "homepage": "https://github.com/petarzarkov/arkv/tree/main/packages/temporal#readme",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/petarzarkov/arkv",
+    "directory": "packages/temporal"
+  }
+}