@leancodepl/api-date-datefns/index.cjs.js

Date-fns integration for API date type conversion

'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]; }
  });
});