rn-date 1.0.3 → 1.1.1

package/README.md

@@ -1,17 +1,179 @@
 # rn-date
 
-`rn-date` is a zero-dependency library which fixes the date parsing issue in React Native with Android.
+`rn-date` is a zero-dependency TypeScript library which fixes the date parsing issues in React Native with Android.
+
+## Background
+
+React Native on Android has inconsistent date parsing behavior compared to iOS and web. The native `Date` constructor may parse date strings differently depending on the platform and format. This library provides consistent, reliable date parsing across all platforms.
+
+## Features
+
+- **Zero runtime dependencies** - Minimal bundle size impact
+- **TypeScript support** - Full type definitions included
+- **Consistent parsing** - Same behavior across iOS, Android, and web
+- **Multiple format support**:
+  - Date-only: `YYYY-MM-DD`
+  - DateTime: `YYYY-MM-DD HH:MM:SS`
+  - ISO 8601: `YYYY-MM-DDTHH:MM:SS.sssZ`
+- **Utility methods** - Convenient formatting and validation
 
 ## Installation
 
 ```bash
 yarn add rn-date
+# or
+npm install rn-date
 ```
 
 ## Usage
 
+### Basic Import
+
 ```ts
 import { RnDate } from 'rn-date';
+```
+
+### Creating Dates
+
+```ts
+// Current date and time
+const now = new RnDate();
 
-const date = new RnDate('2020-01-01T00:00:00.000Z'); // instead of new Date('2020-01-01T00:00:00.000Z')
+// Date-only format (parsed as UTC)
+const date = new RnDate('2022-01-01');
+
+// DateTime with space separator (parsed as local time)
+const dateTime = new RnDate('2022-01-01 17:04:03');
+
+// ISO 8601 format (UTC with timezone)
+const isoDate = new RnDate('2022-01-01T00:00:00.000Z');
 ```
+
+### Using with Date Methods
+
+`RnDate` extends the native `Date` class, so all standard Date methods are available:
+
+```ts
+const date = new RnDate('2022-01-01 17:04:03');
+
+// Standard Date methods work as expected
+date.getFullYear();  // 2022
+date.getMonth();     // 0 (January)
+date.getDate();      // 1
+date.getHours();     // 17
+date.getMinutes();   // 4
+date.getSeconds();   // 3
+
+// Format methods
+date.toISOString();      // "2022-01-01T16:04:03.000Z" (UTC)
+date.toDateString();     // "Sat Jan 01 2022"
+date.toString();         // Full date string
+
+// Timestamp
+date.getTime();          // 1641056643000
+```
+
+## API Reference
+
+### Constructor
+
+#### `new RnDate(dateString?: string)`
+
+Creates a new RnDate instance.
+
+**Parameters:**
+- `dateString` (`string | undefined`) - The date string to parse
+
+**Supported formats:**
+- `YYYY-MM-DD` - Date only (parsed as UTC)
+- `YYYY-MM-DD HH:MM:SS` - DateTime (parsed as local time)
+- `YYYY-MM-DDTHH:MM:SS.sssZ` - ISO 8601 format (UTC)
+- `undefined` or `null` - Current date and time
+
+**Throws:**
+- `TypeError` - If `dateString` is not a string or undefined
+
+**Examples:**
+
+```ts
+// Current date
+const now = new RnDate();
+const alsoNow = new RnDate(undefined);
+
+// Specific date (UTC)
+const date = new RnDate('2022-01-01');
+
+// Specific datetime (local time)
+const dateTime = new RnDate('2022-01-01 17:04:03');
+
+// ISO format (UTC)
+const isoDate = new RnDate('2022-01-01T00:00:00.000Z');
+
+// Invalid date returns Invalid Date
+const invalid = new RnDate('invalid-date');
+console.log(invalid.toString()); // "Invalid Date"
+```
+
+### Methods
+
+#### `isValid(): boolean`
+
+Checks if this RnDate represents a valid date.
+
+**Returns:** `boolean` - `true` if the date is valid, `false` otherwise
+
+**Example:**
+
+```ts
+const validDate = new RnDate('2022-01-01');
+validDate.isValid(); // true
+
+const invalidDate = new RnDate('invalid');
+invalidDate.isValid(); // false
+```
+
+---
+
+#### `toDateFormat(): string`
+
+Formats the date as a string in the format `YYYY-MM-DD` (UTC).
+
+**Returns:** `string` - The formatted date string
+
+**Example:**
+
+```ts
+const date = new RnDate('2022-01-01 17:04:03');
+date.toDateFormat(); // "2022-01-01"
+```
+
+---
+
+#### `toDateTimeFormat(): string`
+
+Formats the date and time as a string in the format `YYYY-MM-DD HH:MM:SS` (local time).
+
+**Returns:** `string` - The formatted datetime string
+
+**Example:**
+
+```ts
+const date = new RnDate('2022-01-01 17:04:03');
+date.toDateTimeFormat(); // "2022-01-01 17:04:03"
+```
+
+## Platform Differences
+
+The native `Date` constructor has platform-specific behaviors:
+
+| Format | iOS/Web | Android (without fix) | Android (with RnDate) |
+|--------|---------|----------------------|----------------------|
+| `YYYY-MM-DD` | UTC | Local (inconsistent) | UTC (consistent) |
+| `YYYY-MM-DD HH:MM:SS` | Local | Local | Local |
+| `YYYY-MM-DDTHH:MM:SS.sssZ` | UTC | UTC | UTC |
+
+`RnDate` ensures consistent behavior across all platforms.
+
+## License
+
+MIT

package/build/date.d.ts

@@ -1,3 +1,81 @@
+/**
+ * RnDate - A Date class extension that fixes Android date parsing issues in React Native.
+ *
+ * This class addresses the date parsing inconsistencies that occur specifically on
+ * Android devices in React Native applications. It provides reliable parsing for:
+ * - Date-only format: YYYY-MM-DD
+ * - DateTime format: YYYY-MM-DD HH:MM:SS
+ * - ISO 8601 format: YYYY-MM-DDTHH:MM:SS.sssZ
+ *
+ * @example
+ * ```ts
+ * import { RnDate } from 'rn-date';
+ *
+ * const date = new RnDate('2022-01-01');
+ * const dateTime = new RnDate('2022-01-01 17:04:03');
+ * const isoDate = new RnDate('2022-01-01T00:00:00.000Z');
+ * ```
+ *
+ * @class RnDate
+ * @extends {Date}
+ */
 export declare class RnDate extends Date {
+    /**
+     * Creates a new RnDate instance.
+     *
+     * @param {string | undefined} dateString - The date string to parse. Supports formats:
+     *   - YYYY-MM-DD (date only)
+     *   - YYYY-MM-DD HH:MM:SS (date and time separated by space)
+     *   - YYYY-MM-DDTHH:MM:SS.sssZ (ISO 8601 format)
+     *   - If undefined or empty, creates a date with the current date and time
+     * @throws {TypeError} If dateString is not a string or undefined
+     *
+     * @example
+     * ```ts
+     * new RnDate() // Current date
+     * new RnDate('2022-01-01') // Date only
+     * new RnDate('2022-01-01 17:04:03') // DateTime with space
+     * new RnDate('2022-01-01T00:00:00.000Z') // ISO format
+     * ```
+     */
     constructor(dateString?: string);
+    /**
+     * Checks if this RnDate represents a valid date.
+     *
+     * @returns {boolean} True if the date is valid, false otherwise
+     *
+     * @example
+     * ```ts
+     * const validDate = new RnDate('2022-01-01');
+     * validDate.isValid(); // true
+     *
+     * const invalidDate = new RnDate('invalid');
+     * invalidDate.isValid(); // false
+     * ```
+     */
+    isValid(): boolean;
+    /**
+     * Formats the date as a string in the format YYYY-MM-DD.
+     *
+     * @returns {string} The formatted date string
+     *
+     * @example
+     * ```ts
+     * const date = new RnDate('2022-01-01 17:04:03');
+     * date.toDateFormat(); // "2022-01-01"
+     * ```
+     */
+    toDateFormat(): string;
+    /**
+     * Formats the date and time as a string in the format YYYY-MM-DD HH:MM:SS.
+     *
+     * @returns {string} The formatted datetime string
+     *
+     * @example
+     * ```ts
+     * const date = new RnDate('2022-01-01 17:04:03');
+     * date.toDateTimeFormat(); // "2022-01-01 17:04:03"
+     * ```
+     */
+    toDateTimeFormat(): string;
 }

package/build/date.js

@@ -1,21 +1,215 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RnDate = void 0;
+/**
+ * RnDate - A Date class extension that fixes Android date parsing issues in React Native.
+ *
+ * This class addresses the date parsing inconsistencies that occur specifically on
+ * Android devices in React Native applications. It provides reliable parsing for:
+ * - Date-only format: YYYY-MM-DD
+ * - DateTime format: YYYY-MM-DD HH:MM:SS
+ * - ISO 8601 format: YYYY-MM-DDTHH:MM:SS.sssZ
+ *
+ * @example
+ * ```ts
+ * import { RnDate } from 'rn-date';
+ *
+ * const date = new RnDate('2022-01-01');
+ * const dateTime = new RnDate('2022-01-01 17:04:03');
+ * const isoDate = new RnDate('2022-01-01T00:00:00.000Z');
+ * ```
+ *
+ * @class RnDate
+ * @extends {Date}
+ */
 class RnDate extends Date {
+    /**
+     * Creates a new RnDate instance.
+     *
+     * @param {string | undefined} dateString - The date string to parse. Supports formats:
+     *   - YYYY-MM-DD (date only)
+     *   - YYYY-MM-DD HH:MM:SS (date and time separated by space)
+     *   - YYYY-MM-DDTHH:MM:SS.sssZ (ISO 8601 format)
+     *   - If undefined or empty, creates a date with the current date and time
+     * @throws {TypeError} If dateString is not a string or undefined
+     *
+     * @example
+     * ```ts
+     * new RnDate() // Current date
+     * new RnDate('2022-01-01') // Date only
+     * new RnDate('2022-01-01 17:04:03') // DateTime with space
+     * new RnDate('2022-01-01T00:00:00.000Z') // ISO format
+     * ```
+     */
     constructor(dateString) {
+        // Initialize with NaN, will be set below
+        super(NaN);
+        // Handle undefined
         if (dateString === undefined || dateString === null) {
-            super();
+            this.setTime(Date.now());
+            return;
         }
-        else {
-            const dateParam = dateString.split(/[\s-:]/);
-            if (dateParam.length > 3) {
-                dateParam[1] = (parseInt(dateParam[1], 10) - 1).toString();
-                super(...dateParam);
+        // Validate input type
+        if (typeof dateString !== 'string') {
+            throw new TypeError(`RnDate expects a string argument, received ${typeof dateString}`);
+        }
+        // Handle empty string - should return Invalid Date like native Date
+        if (dateString === '') {
+            // Leave as NaN (Invalid Date)
+            return;
+        }
+        // Trim whitespace
+        const trimmedDate = dateString.trim();
+        // Check for ISO format (contains 'T')
+        if (trimmedDate.includes('T')) {
+            // ISO format - let native Date handle it
+            const tempDate = new Date(trimmedDate);
+            this.setTime(tempDate.getTime());
+            return;
+        }
+        // Check for space-separated datetime format (YYYY-MM-DD HH:MM:SS)
+        const spaceIndex = trimmedDate.indexOf(' ');
+        if (spaceIndex !== -1) {
+            // Split into date and time parts
+            const datePart = trimmedDate.substring(0, spaceIndex);
+            const timePart = trimmedDate.substring(spaceIndex + 1);
+            // Parse date components (YYYY-MM-DD)
+            const dateComponents = datePart.split('-');
+            if (dateComponents.length !== 3) {
+                // Invalid format, fall back to native parsing
+                const tempDate = new Date(trimmedDate);
+                this.setTime(tempDate.getTime());
+                return;
+            }
+            const [yearStr, monthStr, dayStr] = dateComponents;
+            const year = parseInt(yearStr, 10);
+            const monthValue = parseInt(monthStr, 10); // 1-based month
+            const day = parseInt(dayStr, 10);
+            // Validate date components (month 1-12, day 1-31)
+            if (isNaN(year) ||
+                isNaN(monthValue) ||
+                isNaN(day) ||
+                monthValue < 1 ||
+                monthValue > 12 ||
+                day < 1 ||
+                day > 31) {
+                // Invalid date, fall back to native parsing
+                const tempDate = new Date(trimmedDate);
+                this.setTime(tempDate.getTime());
+                return;
+            }
+            const month = monthValue - 1; // Convert to 0-based month
+            // Parse time components (HH:MM:SS)
+            const timeComponents = timePart.split(':');
+            let hours = 0, minutes = 0, seconds = 0, milliseconds = 0;
+            if (timeComponents.length >= 1) {
+                hours = parseInt(timeComponents[0], 10);
+            }
+            if (timeComponents.length >= 2) {
+                minutes = parseInt(timeComponents[1], 10);
             }
-            else {
-                super(dateString);
+            if (timeComponents.length >= 3) {
+                // Handle potential milliseconds (e.g., "SS.fff" or "SS")
+                const secondsPart = timeComponents[2];
+                const dotIndex = secondsPart.indexOf('.');
+                if (dotIndex !== -1) {
+                    seconds = parseInt(secondsPart.substring(0, dotIndex), 10);
+                    const msStr = secondsPart.substring(dotIndex + 1);
+                    // Pad or truncate milliseconds to 3 digits
+                    milliseconds = parseInt(msStr.padEnd(3, '0').substring(0, 3), 10);
+                }
+                else {
+                    seconds = parseInt(secondsPart, 10);
+                }
             }
+            // Use local time for space-separated datetime (matching native behavior)
+            const tempDate = new Date(year, month, day, hours, minutes, seconds, milliseconds);
+            this.setTime(tempDate.getTime());
+            return;
         }
+        // Check for date-only format (YYYY-MM-DD)
+        const dateComponents = trimmedDate.split('-');
+        if (dateComponents.length === 3) {
+            const [yearStr, monthStr, dayStr] = dateComponents;
+            const year = parseInt(yearStr, 10);
+            const monthValue = parseInt(monthStr, 10); // 1-based month
+            const day = parseInt(dayStr, 10);
+            // Validate date components format and values
+            // Month should be 1-12, day should be 1-31 (basic validation)
+            if (!isNaN(year) &&
+                !isNaN(monthValue) &&
+                !isNaN(day) &&
+                yearStr.length === 4 &&
+                monthStr.length >= 1 &&
+                monthStr.length <= 2 &&
+                dayStr.length >= 1 &&
+                dayStr.length <= 2 &&
+                monthValue >= 1 &&
+                monthValue <= 12 &&
+                day >= 1 &&
+                day <= 31) {
+                const month = monthValue - 1; // Convert to 0-based month
+                // Use Date.UTC to create UTC timestamp (matching native behavior)
+                const time = Date.UTC(year, month, day);
+                this.setTime(time);
+                return;
+            }
+        }
+        // Fallback: try native parsing for any other format
+        const tempDate = new Date(trimmedDate);
+        this.setTime(tempDate.getTime());
+    }
+    /**
+     * Checks if this RnDate represents a valid date.
+     *
+     * @returns {boolean} True if the date is valid, false otherwise
+     *
+     * @example
+     * ```ts
+     * const validDate = new RnDate('2022-01-01');
+     * validDate.isValid(); // true
+     *
+     * const invalidDate = new RnDate('invalid');
+     * invalidDate.isValid(); // false
+     * ```
+     */
+    isValid() {
+        return !isNaN(this.getTime());
+    }
+    /**
+     * Formats the date as a string in the format YYYY-MM-DD.
+     *
+     * @returns {string} The formatted date string
+     *
+     * @example
+     * ```ts
+     * const date = new RnDate('2022-01-01 17:04:03');
+     * date.toDateFormat(); // "2022-01-01"
+     * ```
+     */
+    toDateFormat() {
+        const year = this.getUTCFullYear();
+        const month = String(this.getUTCMonth() + 1).padStart(2, '0');
+        const day = String(this.getUTCDate()).padStart(2, '0');
+        return `${year}-${month}-${day}`;
+    }
+    /**
+     * Formats the date and time as a string in the format YYYY-MM-DD HH:MM:SS.
+     *
+     * @returns {string} The formatted datetime string
+     *
+     * @example
+     * ```ts
+     * const date = new RnDate('2022-01-01 17:04:03');
+     * date.toDateTimeFormat(); // "2022-01-01 17:04:03"
+     * ```
+     */
+    toDateTimeFormat() {
+        const date = this.toDateFormat();
+        const hours = String(this.getHours()).padStart(2, '0');
+        const minutes = String(this.getMinutes()).padStart(2, '0');
+        const seconds = String(this.getSeconds()).padStart(2, '0');
+        return `${date} ${hours}:${minutes}:${seconds}`;
     }
 }
 exports.RnDate = RnDate;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rn-date",
-  "version": "1.0.3",
+  "version": "1.1.1",
   "author": "maxgfr",
   "license": "MIT",
   "description": "A zero-dependency library which fixes the date parsing issue in React Native with Android",
@@ -46,22 +46,22 @@
     "@semantic-release/github": "^8.0.7",
     "@semantic-release/npm": "^9.0.1",
     "@semantic-release/release-notes-generator": "^10.0.3",
-    "@swc-node/register": "1.5.4",
-    "@swc/cli": "0.1.57",
-    "@swc/core": "1.3.21",
-    "@swc/jest": "0.2.23",
-    "@types/jest": "29.2.3",
-    "@types/node": "18.11.10",
-    "@typescript-eslint/eslint-plugin": "5.45.0",
-    "@typescript-eslint/parser": "5.45.0",
-    "eslint": "8.29.0",
-    "eslint-config-prettier": "8.5.0",
-    "eslint-plugin-jest": "27.1.6",
-    "jest": "29.3.1",
-    "nodemon": "2.0.20",
-    "prettier": "2.8.0",
+    "@swc-node/register": "1.11.1",
+    "@swc/cli": "0.7.9",
+    "@swc/core": "1.15.3",
+    "@swc/jest": "0.2.39",
+    "@types/jest": "29.5.14",
+    "@types/node": "18.19.130",
+    "@typescript-eslint/eslint-plugin": "5.62.0",
+    "@typescript-eslint/parser": "5.62.0",
+    "eslint": "8.57.1",
+    "eslint-config-prettier": "8.10.2",
+    "eslint-plugin-jest": "27.9.0",
+    "jest": "29.7.0",
+    "nodemon": "2.0.22",
+    "prettier": "2.8.8",
     "rimraf": "3.0.2",
     "semantic-release": "19.0.5",
-    "typescript": "4.9.3"
+    "typescript": "4.9.5"
   }
 }