@leancodepl/api-date-datefns 8.5.0 → 8.5.1

package/README.md

@@ -0,0 +1,130 @@
+# @leancodepl/api-date-datefns
+
+Date conversion utilities using date-fns for API date types.
+
+## Installation
+
+```bash
+npm install @leancodepl/api-date-datefns
+# or
+yarn add @leancodepl/api-date-datefns
+```
+
+## API
+
+### `fromApiDate(date)`
+
+Converts ApiDateOnly to JavaScript Date using date-fns.
+
+**Parameters:**
+
+- `date: ApiDateOnly` - The API date string to convert
+
+**Returns:** JavaScript Date object
+
+### `toApiDate(date)`
+
+Converts JavaScript Date to ApiDateOnly using date-fns.
+
+**Parameters:**
+
+- `date: Date` - The JavaScript Date to convert
+
+**Returns:** ApiDateOnly string
+
+### `fromApiTime(time)`
+
+Converts ApiTimeOnly to JavaScript Date using date-fns.
+
+**Parameters:**
+
+- `time: ApiTimeOnly` - The API time string to convert
+
+**Returns:** JavaScript Date object
+
+### `toApiTime(time)`
+
+Converts JavaScript Date to ApiTimeOnly using date-fns.
+
+**Parameters:**
+
+- `time: Date` - The JavaScript Date to convert
+
+**Returns:** ApiTimeOnly string
+
+### `fromApiDateTimeOffset(dateTimeOffset)`
+
+Converts ApiDateTimeOffset to JavaScript Date using date-fns.
+
+**Parameters:**
+
+- `dateTimeOffset: ApiDateTimeOffset` - The API datetime with offset string to convert
+
+**Returns:** JavaScript Date object
+
+### `toApiDateTimeOffset(dateTimeOffset)`
+
+Converts JavaScript Date to ApiDateTimeOffset using date-fns.
+
+**Parameters:**
+
+- `dateTimeOffset: Date` - The JavaScript Date to convert
+
+**Returns:** ApiDateTimeOffset string
+
+### `fromApiTimeSpan(timeSpan)`
+
+Converts ApiTimeSpan to milliseconds using date-fns.
+
+**Parameters:**
+
+- `timeSpan: ApiTimeSpan` - The API timespan string to convert
+
+**Returns:** Duration in milliseconds
+
+### `toApiTimeSpan(differenceInMilliseconds)`
+
+Converts milliseconds to ApiTimeSpan using date-fns.
+
+**Parameters:**
+
+- `differenceInMilliseconds: number` - The duration in milliseconds to convert
+
+**Returns:** ApiTimeSpan string
+
+## Usage Examples
+
+### Date Conversion
+
+```typescript
+import { fromApiDate, toApiDate } from "@leancodepl/api-date-datefns"
+
+const apiDate = "2023-12-25"
+const jsDate = fromApiDate(apiDate)
+console.log(jsDate) // Date object
+
+const convertedBack = toApiDate(jsDate)
+console.log(convertedBack) // '2023-12-25'
+```
+
+### Time Conversion
+
+```typescript
+import { fromApiTime, toApiTime } from "@leancodepl/api-date-datefns"
+
+const apiTime = "14:30:00"
+const jsDate = fromApiTime(apiTime)
+const convertedBack = toApiTime(jsDate)
+console.log(convertedBack) // '14:30:00'
+```
+
+### DateTime with Offset
+
+```typescript
+import { fromApiDateTimeOffset, toApiDateTimeOffset } from "@leancodepl/api-date-datefns"
+
+const apiDateTime = "2023-12-25T14:30:00+01:00"
+const jsDate = fromApiDateTimeOffset(apiDateTime)
+const convertedBack = toApiDateTimeOffset(jsDate)
+console.log(convertedBack) // '2023-12-25T14:30:00+01:00'
+```

package/index.cjs.default.js

@@ -0,0 +1 @@
+exports._default = require('./index.cjs.js').default;

package/index.cjs.js

@@ -0,0 +1,119 @@
+'use strict';
+
+var apiDate = require('@leancodepl/api-date');
+var dateFns = require('date-fns');
+var apiDateUtils = require('@leancodepl/api-date-utils');
+
+function fromApiTime(time) {
+    if (!time) {
+        return undefined;
+    }
+    return dateFns.parse(time, "HH:mm:ss.SSS", new Date());
+}
+
+function toApiTime(time) {
+    if (!time) {
+        return undefined;
+    }
+    return dateFns.format(time, "HH:mm:ss.SSS");
+}
+
+function fromApiDate(date) {
+    if (date && typeof date === "string") {
+        return dateFns.parse(date, "yyyy-MM-dd", new Date());
+    }
+    return undefined;
+}
+
+function toApiDate(date) {
+    if (!date) {
+        return undefined;
+    }
+    return dateFns.format(date, "yyyy-MM-dd");
+}
+
+function fromApiDateTimeOffset(dateTimeOffset) {
+    if (!dateTimeOffset) {
+        return undefined;
+    }
+    return dateFns.parse(dateTimeOffset, "yyyy-MM-dd'T'HH:mm:ss.SSSXXX", new Date());
+}
+
+function toApiDateTimeOffset(dateTimeOffset) {
+    if (!dateTimeOffset) {
+        return undefined;
+    }
+    return dateFns.format(dateTimeOffset, "yyyy-MM-dd'T'HH:mm:ss.SSSXXX");
+}
+
+function fromApiTimeSpan(timeSpan) {
+    if (!timeSpan) {
+        return undefined;
+    }
+    const parsedApiTimeSpan = apiDateUtils.parseApiTimeSpan(timeSpan);
+    const parsedApiTimeSpanValues = parsedApiTimeSpan.values;
+    const daysInMilliseconds = dateFns.hoursToMilliseconds(parsedApiTimeSpanValues.days * 24);
+    const hoursInMilliseconds = dateFns.hoursToMilliseconds(parsedApiTimeSpanValues.hours);
+    const minutesInMilliseconds = dateFns.minutesToMilliseconds(parsedApiTimeSpanValues.minutes);
+    const secondsInMilliseconds = dateFns.secondsToMilliseconds(parsedApiTimeSpanValues.seconds);
+    const differenceInMilliseconds = daysInMilliseconds + hoursInMilliseconds + minutesInMilliseconds + secondsInMilliseconds + parsedApiTimeSpanValues.milliseconds;
+    const signBasedMultiplier = parsedApiTimeSpan.sign === "-" ? -1 : 1;
+    return signBasedMultiplier * differenceInMilliseconds;
+}
+
+function padTo2(x) {
+    var _x_toFixed;
+    const stringified = (_x_toFixed = x == null ? void 0 : x.toFixed(0)) != null ? _x_toFixed : "0";
+    return stringified.padStart(2, "0");
+}
+
+function parseDifferenceInMilliseconds(differenceInMilliseconds) {
+    const milliseconds = differenceInMilliseconds % 1000;
+    const seconds = Math.floor(differenceInMilliseconds / 1000 % 60);
+    const minutes = Math.floor(differenceInMilliseconds / (1000 * 60) % 60);
+    const hours = Math.floor(differenceInMilliseconds / (1000 * 60 * 60) % 24);
+    const days = Math.floor(differenceInMilliseconds / (1000 * 60 * 60 * 24));
+    return {
+        milliseconds,
+        seconds,
+        minutes,
+        hours,
+        days
+    };
+}
+
+function toApiTimeSpan(differenceInMilliseconds) {
+    let stringTimeSpan = "";
+    if (!differenceInMilliseconds) {
+        return undefined;
+    }
+    const isNegative = differenceInMilliseconds < 0;
+    const absDifferenceInMilliseconds = Math.abs(differenceInMilliseconds);
+    const { milliseconds, seconds, minutes, hours, days } = parseDifferenceInMilliseconds(absDifferenceInMilliseconds);
+    if (isNegative) {
+        stringTimeSpan += "-";
+    }
+    if (days > 0) {
+        stringTimeSpan += `${days}.`;
+    }
+    stringTimeSpan += `${padTo2(hours)}:${padTo2(minutes)}:${padTo2(seconds)}`;
+    if (milliseconds > 0) {
+        stringTimeSpan += `.${milliseconds}`;
+    }
+    return stringTimeSpan;
+}
+
+exports.fromApiDate = fromApiDate;
+exports.fromApiDateTimeOffset = fromApiDateTimeOffset;
+exports.fromApiTime = fromApiTime;
+exports.fromApiTimeSpan = fromApiTimeSpan;
+exports.toApiDate = toApiDate;
+exports.toApiDateTimeOffset = toApiDateTimeOffset;
+exports.toApiTime = toApiTime;
+exports.toApiTimeSpan = toApiTimeSpan;
+Object.keys(apiDate).forEach(function (k) {
+    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+        enumerable: true,
+        get: function () { return apiDate[k]; }
+    });
+});

package/index.cjs.mjs

@@ -0,0 +1,2 @@
+export * from './index.cjs.js';
+export { _default as default } from './index.cjs.default.js';

package/index.d.ts

@@ -0,0 +1 @@
+export * from "./src/index";

package/index.esm.js

@@ -0,0 +1,104 @@
+export * from '@leancodepl/api-date';
+import { parse, format, hoursToMilliseconds, minutesToMilliseconds, secondsToMilliseconds } from 'date-fns';
+import { parseApiTimeSpan } from '@leancodepl/api-date-utils';
+
+function fromApiTime(time) {
+    if (!time) {
+        return undefined;
+    }
+    return parse(time, "HH:mm:ss.SSS", new Date());
+}
+
+function toApiTime(time) {
+    if (!time) {
+        return undefined;
+    }
+    return format(time, "HH:mm:ss.SSS");
+}
+
+function fromApiDate(date) {
+    if (date && typeof date === "string") {
+        return parse(date, "yyyy-MM-dd", new Date());
+    }
+    return undefined;
+}
+
+function toApiDate(date) {
+    if (!date) {
+        return undefined;
+    }
+    return format(date, "yyyy-MM-dd");
+}
+
+function fromApiDateTimeOffset(dateTimeOffset) {
+    if (!dateTimeOffset) {
+        return undefined;
+    }
+    return parse(dateTimeOffset, "yyyy-MM-dd'T'HH:mm:ss.SSSXXX", new Date());
+}
+
+function toApiDateTimeOffset(dateTimeOffset) {
+    if (!dateTimeOffset) {
+        return undefined;
+    }
+    return format(dateTimeOffset, "yyyy-MM-dd'T'HH:mm:ss.SSSXXX");
+}
+
+function fromApiTimeSpan(timeSpan) {
+    if (!timeSpan) {
+        return undefined;
+    }
+    const parsedApiTimeSpan = parseApiTimeSpan(timeSpan);
+    const parsedApiTimeSpanValues = parsedApiTimeSpan.values;
+    const daysInMilliseconds = hoursToMilliseconds(parsedApiTimeSpanValues.days * 24);
+    const hoursInMilliseconds = hoursToMilliseconds(parsedApiTimeSpanValues.hours);
+    const minutesInMilliseconds = minutesToMilliseconds(parsedApiTimeSpanValues.minutes);
+    const secondsInMilliseconds = secondsToMilliseconds(parsedApiTimeSpanValues.seconds);
+    const differenceInMilliseconds = daysInMilliseconds + hoursInMilliseconds + minutesInMilliseconds + secondsInMilliseconds + parsedApiTimeSpanValues.milliseconds;
+    const signBasedMultiplier = parsedApiTimeSpan.sign === "-" ? -1 : 1;
+    return signBasedMultiplier * differenceInMilliseconds;
+}
+
+function padTo2(x) {
+    var _x_toFixed;
+    const stringified = (_x_toFixed = x == null ? void 0 : x.toFixed(0)) != null ? _x_toFixed : "0";
+    return stringified.padStart(2, "0");
+}
+
+function parseDifferenceInMilliseconds(differenceInMilliseconds) {
+    const milliseconds = differenceInMilliseconds % 1000;
+    const seconds = Math.floor(differenceInMilliseconds / 1000 % 60);
+    const minutes = Math.floor(differenceInMilliseconds / (1000 * 60) % 60);
+    const hours = Math.floor(differenceInMilliseconds / (1000 * 60 * 60) % 24);
+    const days = Math.floor(differenceInMilliseconds / (1000 * 60 * 60 * 24));
+    return {
+        milliseconds,
+        seconds,
+        minutes,
+        hours,
+        days
+    };
+}
+
+function toApiTimeSpan(differenceInMilliseconds) {
+    let stringTimeSpan = "";
+    if (!differenceInMilliseconds) {
+        return undefined;
+    }
+    const isNegative = differenceInMilliseconds < 0;
+    const absDifferenceInMilliseconds = Math.abs(differenceInMilliseconds);
+    const { milliseconds, seconds, minutes, hours, days } = parseDifferenceInMilliseconds(absDifferenceInMilliseconds);
+    if (isNegative) {
+        stringTimeSpan += "-";
+    }
+    if (days > 0) {
+        stringTimeSpan += `${days}.`;
+    }
+    stringTimeSpan += `${padTo2(hours)}:${padTo2(minutes)}:${padTo2(seconds)}`;
+    if (milliseconds > 0) {
+        stringTimeSpan += `.${milliseconds}`;
+    }
+    return stringTimeSpan;
+}
+
+export { fromApiDate, fromApiDateTimeOffset, fromApiTime, fromApiTimeSpan, toApiDate, toApiDateTimeOffset, toApiTime, toApiTimeSpan };

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@leancodepl/api-date-datefns",
-  "version": "8.5.0",
+  "version": "8.5.1",
   "license": "Apache-2.0",
   "dependencies": {
-    "@leancodepl/api-date": "8.5.0",
-    "@leancodepl/api-date-utils": "8.5.0",
+    "@leancodepl/api-date": "8.5.1",
+    "@leancodepl/api-date-utils": "8.5.1",
     "date-fns": ">=2.0.0"
   },
   "devDependencies": {
@@ -40,11 +40,6 @@
     "name": "LeanCode",
     "url": "https://leancode.co"
   },
-  "files": [
-    "dist",
-    "README.md",
-    "CHANGELOG.md"
-  ],
   "sideEffects": false,
   "exports": {
     "./package.json": "./package.json",

package/src/index.d.ts

@@ -0,0 +1,9 @@
+export * from "@leancodepl/api-date";
+export * from "./lib/time/fromApiTime";
+export * from "./lib/time/toApiTime";
+export * from "./lib/date/fromApiDate";
+export * from "./lib/date/toApiDate";
+export * from "./lib/dateTimeOffset/fromApiDateTimeOffset";
+export * from "./lib/dateTimeOffset/toApiDateTimeOffset";
+export * from "./lib/timeSpan/fromApiTimeSpan";
+export * from "./lib/timeSpan/toApiTimeSpan";

package/src/lib/date/fromApiDate.d.ts

@@ -0,0 +1,19 @@
+import type { ApiDateOnly } from "@leancodepl/api-date";
+/**
+ * Converts ApiDateOnly to JavaScript Date using date-fns.
+ *
+ * Parses API date string format to JavaScript Date object with support
+ * for optional parameters. Uses date-fns parse function internally.
+ *
+ * @param date - The API date string to convert
+ * @returns JavaScript Date object or undefined if date is undefined
+ * @example
+ * ```typescript
+ * import { fromApiDate } from '@leancodepl/api-date-datefns';
+ *
+ * const jsDate = fromApiDate('2023-12-25');
+ * console.log(jsDate); // Date object for December 25, 2023
+ * ```
+ */
+export declare function fromApiDate(date: ApiDateOnly): Date;
+export declare function fromApiDate(date: ApiDateOnly | undefined): Date | undefined;

package/src/lib/date/toApiDate.d.ts

@@ -0,0 +1,19 @@
+import type { ApiDateOnly } from "@leancodepl/api-date";
+/**
+ * Converts JavaScript Date to ApiDateOnly using date-fns.
+ *
+ * Formats JavaScript Date object to API date string format with support
+ * for optional parameters. Uses date-fns format function internally.
+ *
+ * @param date - The JavaScript Date to convert
+ * @returns ApiDateOnly string or undefined if date is undefined
+ * @example
+ * ```typescript
+ * import { toApiDate } from '@leancodepl/api-date-datefns';
+ *
+ * const apiDate = toApiDate(new Date('2023-12-25'));
+ * console.log(apiDate); // '2023-12-25'
+ * ```
+ */
+export declare function toApiDate(date: Date): ApiDateOnly;
+export declare function toApiDate(date: Date | undefined): ApiDateOnly | undefined;

package/src/lib/dateTimeOffset/fromApiDateTimeOffset.d.ts

@@ -0,0 +1,6 @@
+import type { ApiDateTimeOffset } from "@leancodepl/api-date";
+/**
+ *This function handles at most milliseconds precision, smaller units are lost in conversion process
+ */
+export declare function fromApiDateTimeOffset(dateTimeOffset: ApiDateTimeOffset): Date;
+export declare function fromApiDateTimeOffset(dateTimeOffset: ApiDateTimeOffset | undefined): Date | undefined;

package/src/lib/dateTimeOffset/toApiDateTimeOffset.d.ts

@@ -0,0 +1,6 @@
+import type { ApiDateTimeOffset } from "@leancodepl/api-date";
+/**
+ *This function handles at most milliseconds precision, smaller units are lost in conversion process
+ */
+export declare function toApiDateTimeOffset(dateTimeOffset: Date): ApiDateTimeOffset;
+export declare function toApiDateTimeOffset(dateTimeOffset: Date | undefined): ApiDateTimeOffset | undefined;

package/src/lib/time/fromApiTime.d.ts

@@ -0,0 +1,6 @@
+import type { ApiTimeOnly } from "@leancodepl/api-date";
+/**
+ *This function handles at most milliseconds precision, smaller units are lost in conversion process
+ */
+export declare function fromApiTime(time: ApiTimeOnly): Date;
+export declare function fromApiTime(time: ApiTimeOnly | undefined): Date | undefined;

package/src/lib/time/toApiTime.d.ts

@@ -0,0 +1,6 @@
+import type { ApiTimeOnly } from "@leancodepl/api-date";
+/**
+ *This function handles at most milliseconds precision, smaller units are lost in conversion process
+ */
+export declare function toApiTime(time: Date): ApiTimeOnly;
+export declare function toApiTime(time: Date | undefined): ApiTimeOnly | undefined;

package/src/lib/timeSpan/fromApiTimeSpan.d.ts

@@ -0,0 +1,3 @@
+import type { ApiTimeSpan } from "@leancodepl/api-date";
+export declare function fromApiTimeSpan(timeSpan: ApiTimeSpan): number;
+export declare function fromApiTimeSpan(timeSpan: ApiTimeSpan | undefined): number | undefined;

package/src/lib/timeSpan/toApiTimeSpan.d.ts

@@ -0,0 +1,3 @@
+import type { ApiTimeSpan } from "@leancodepl/api-date";
+export declare function toApiTimeSpan(differenceInMilliseconds: number): ApiTimeSpan;
+export declare function toApiTimeSpan(differenceInMilliseconds: number | undefined): ApiTimeSpan | undefined;

package/src/lib/utils/padTo2.d.ts

@@ -0,0 +1 @@
+export declare function padTo2(x?: number): string;

package/src/lib/utils/parseDifferenceInMilliseconds.d.ts

@@ -0,0 +1,7 @@
+export declare function parseDifferenceInMilliseconds(differenceInMilliseconds: number): {
+    milliseconds: number;
+    seconds: number;
+    minutes: number;
+    hours: number;
+    days: number;
+};