you-dont-need / you-dont-need-momentjs

List of functions which you can use to replace moment.js + ESLint Plugin

English | 简体中文

You Don't Need

People choose popular projects, often not because it applies to their problems.

Contents

• Packages
  • JavaScript Packages
• Languages
• Programming Practices
• Miscellaneous

Packages

JavaScript Packages

• You don't (may not) need Lodash/Underscore - List of JavaScript methods which you can use natively + ESLint Plugin.
• You don't (may not) need Moment.js - List of date-fns or native functions which you can use to replace moment.js.
• You Might Not Need Redux - If you're just learning React, don't make Redux your first choice.
• You Might Not Need React Router - The majority of projects at Facebook don't even use it.
• You Might Not Need jQuery - If you're only targeting more modern browsers, you might not need anything more than what the browser ships with.
• You Might Not Need Axios - The standard window.fetch has all the features you need.
• You Might Not Need Gatsby - A simpler static React stack

Languages

• You Don't Need JavaScript - CSS is powerful, you can do a lot of things without JS.
• You Might Not Need TypeScript (or Static Types) - There's no question that static types can feel good. Biting into a hot glazed donut feels good. But is it really good for you?

Programming Practices

• You Don't Need Loops ➿ - Loops are bullshit. Let's embrace wholemeal programming!
• You Probably Don't Need Derived State (React) - As a general rule, derived state should be used sparingly. All problems with derived state that we have seen can be ultimately reduced to either unconditionally updating state from props or updating state whenever props and state don't match.
• You Might Not Need to Transpile Your JavaScript - In other words if you're transpiling your JavaScript to ES5, you're making your code unnecessarily big and slow to support a minority of the users who will probably upgrade their system by the time you manage to configure your Webpack and Babel! 😉

Miscellaneous

• You Don't Need GUI - Stop relying on GUI; CLI ROCKS.

you-dont-need-momentjs's Issues

Sometimes there is no alternative to Moment.js

Moment.js can be still a useful (and perhaps even the only) library.

JavaScript is a widely used language, not only used by web-browsers.
Most alternative libraries require access to the internet in order to connect to the IANA timezone database and/or rely on Intl Object.

When you use for example mongo shell then

• you don't have connection to the internet
• the shell does not support Intl object. The new mongosh is still in beta-phase
• you don't care about a 300k library. With MongoDB scripts you process much larger documents. Other popular libraries like Node.js or mongoose are even larger.

I am really happy that moment.js is still maintained. So far I did not find any suitable alternative library.

Include info on how to tree shake dynamically imported locales

If locale is required dynamically all languages in the date-fns are loaded into bundle (~160kb). However it is possible to use webpack to trim down the languages added to bundle using Context replacement plugin.

Usage example

const getLocale = (locale) => require(`date-fns/locale/${locale}/index.js`);

const formatDate = (date, formatStyle, locale) => {
    return format(date, formatStyle, {
        locale: getLocale(locale)
    });
};

Config example:

const supportedLocales = ["en", "de", "pl", "it"]
plugins: [
  new ContextReplacementPlugin(/date\-fns[\/\\]/, new RegExp(`[/\\\\\](${supportedLocales.join('|')})[/\\\\\]`)),
]

This results in a language bundle of ~23kb.

dateFns.formatDistance is deprecated. Use distanceInWordsToNow instead.

formatDistance is a date-fns function to replace moment.fromNow()

It's not in the latest version of the package and you cannot find it in the docs anymore.
We should use distanceInWordsToNow instead.

https://date-fns.org/v1.29.0/docs/distanceInWordsToNow

Shall I update the readme?

Time Zone support does exist in date-fns

It would seem that date-fns does at least have some Time Zone support.
https://date-fns.org/v2.9.0/docs/Time-Zones

This information should be updated here:
https://github.com/you-dont-need/You-Dont-Need-Momentjs#brief-comparison

Date-fns v2 is officially released

should upgrade to the official released version from alpha.23 to test out whether there are any breaking changes.

and benchmarking.

ref: https://github.com/date-fns/date-fns/releases/tag/v2.0.0?fbclid=IwAR3rrkytHDkVBxKk6FJOocMHp3qtLn4HZyYnqrD28JfC3QSfYUnXI4_67k4

Add demo gif to README

Disclaimer: This is a bot

It looks like your repo is trending. The github_trending_videos Instgram account automatically shows the demo gifs of trending repos in Github.

Your README doesn't seem to have any demo gifs. Add one and the next time the parser runs it will pick it up and post it on its Instagram feed. If you don't want to just close this issue we won't bother you again.

Example should use UTC timezone

The output result will be affected by timezone, in case if anyone wants to add a new library in the example, output result might be different.

You should add Luxon, moment.js' alternative to itself

I wonder if it would be a good replacement as well. https://moment.github.io/luxon/

How does date-fns compare to dayjs?

Dayjs claims to replicate the momentjs API in 2kb. I've been using it as a replacement recently.

It would be good to add this to the comparison I think.

https://github.com/iamkun/dayjs

Day.js also support token 'Do' e.g. 9th

Day.js has a plugin advancedFormat that allows tokens like Do Q X

// current readme 
dayjs().format('dddd, MMMM D YYYY, h:mm:ss A');
// => "Sunday, September 9 2018, 7:12:49 PM" ⚠️  not support 9th

// however with plugin
import advancedFormat from 'dayjs/plugin/advancedFormat'
dayjs.extend(advancedFormat)
dayjs().format('Q Do k kk X x')

Besides, we might could update the screenshot and the description of this great project. Since it's not just the comparison between moment.js and date-dns, also Day.js and native Date object.

"[email protected]" has incorrect peer dependency "eslint@^5.5.0".

Please update to support eslint 8.9.0

from the docs it does not become clear what exactly the result is of using this plugin.

• does it generate warnings or errors?
• is it configurable to show warnings or errors?
• does it show detailed alternatives as in the examples, when a specific type of momentJS usage is found?

It would be good to actually show an example of ESlint output after using this plugin or make clear how this plugin is useful visually.

Congrats on first 1k github stars!

Congrats to all the contributors! Go team!
🎉 🎉 🎉 🎉 🎉 🎉 🎉 🎉 🎉 🎉

IsSame example is not equivalent

Hello, thanks for this great resource. I'm working on a new version of my date picker and I'm looking to remove momentjs. I was able to use some of the info here to whittle down the functions I needed. You are welcome to look at the full example on stackblitz as make use of what's there.

One thing I noticed is that your IsSame example with a granularity is not equivalent:
new Date(2010, 9, 20).toDateString().substring(4, 7) === new Date(2010, 9, 21).toDateString().substring(4, 7);

While technically does verify that both dates are in Oct this is not what moment/dayjs do. Those libs use their startOf function to take the dates to the beginning of the unit passed and then compare the valueOf. (I think the comparison of dates example should use valueOf as that's a more accurate comparison anyway).

In the provide example moment and dayjs would do the following

moment('2010-10-20').isSame('2010-10-21', 'month');
thisDate = 2010-10-1 //via startOf
compareDate = 2010-10-1
thisDate.valueOf() === compareDate.valueOf() //true

moment('2010-10-20').isSame('2021-10-21', 'month');
thisDate = 2010-10-1
compareDate = 2021-10-1
thisDate.valueOf() === compareDate.valueOf() //false

benchmark

I'd like to see the benchmark of momentjs and the alternative, and see which one is faster.

You-Dont-Need-date-fns

https://github.com/HiZhaoxiaoyang/You-Dont-Need-date-fns.git

subDays into sub_days

hello I tried to use date_fns but there are some problems
I tried to import subDays from 'date-fns/subDays' but it doesn't work.
So I found out something thorough the document.

https://date-fns.org/v1.28.5/docs/subDays
According to this document, date-fns/subDays should be changed to date-fns/sub_days
Am I correct?

Buuuuuuuut I liiiiiiiiike momentjs

Why are native ‘add’ and ‘subtract’ different?

Native add reads:

const now = new Date();
now.setDate(now.getDate() + 7);

Native subtract reads:

new Date(new Date().getTime() - 1000 * 60 * 60 * 24 * 7);

Why are they different? Would the approach used for add not work for subtract or vice-versa? (I tried them and they seemed to work, but when working with times there are so many edge cases that you can never be sure…)

moment js size optimization with webpack

Here is walkaround if needed to reduce moment js size, which is not needed in alternatives. ;)

See if this helps.

https://github.com/jmblog/how-to-optimize-momentjs-with-webpack

Repo description update

List of date-fns or native functions which you can use to replace moment.js + ESLint Plugin

Thanks for this amazing repo. Above is the description of our repo. Since we have dayjs and luxon right now, should we update the description accordingly?

some quick links are not working

You-Dont-Need-any-date-libs

https://github.com/HiZhaoxiaoyang/You-Dont-Need-date-fns.git

Worth discussing non-Gregorian calendar support in Moment alternatives

non-Gregorian calendars (Hebrew, Islamic, Solar, Japanese and a few others) are one of the reasons in the past my teams had to stick with Moment.

It would be interesting to have a table or column in existing table on the state of non-Gregorian support in Moment alternatives

date-fns doesn't support LocaleData

this was a problem for me when I was migrating so I hope it saves anyone sometime intro trying to migrate just to realize you can't do this.

Unable to resolve dependency

Hullo, recently tried to add this plugin to a project only to be faced with some
dependency issue shenanigans

Error Log:

$ npm install --save-dev eslint-plugin-you-dont-need-momentjs
npm ERR! code ERESOLVE
npm ERR! ERESOLVE unable to resolve dependency tree
npm ERR!
npm ERR! While resolving: <Project Name>
npm ERR! Found: [email protected]
npm ERR! node_modules/eslint
npm ERR!   dev eslint@"^7.19.0" from the root project
npm ERR!
npm ERR! Could not resolve dependency:
npm ERR! peer eslint@"^5.5.0" from [email protected]
npm ERR! node_modules/eslint-plugin-you-dont-need-momentjs
npm ERR!   dev eslint-plugin-you-dont-need-momentjs@"*" from the root project
npm ERR!
npm ERR! Fix the upstream dependency conflict, or retry
npm ERR! this command with --force, or --legacy-peer-deps
npm ERR! to accept an incorrect (and potentially broken) dependency resolution.

I don't particularly feel like forcing the install, and help would be appreciated.

Non-date based time expressions lib

I made this pure vanilla library to work with time expressions some time ago. It's pretty small, well tested, completely documented, easy to use and works on both Node.js(any version) and browser(any browser/version).

Maybe somebody could get interested.

Ex.:

const Kairos = require('kairos');

const time = Kairos.new('10:30', 'hh:mm');
time.divide(2);
time.toString('hh:mm:ss'); // 05:15:00
time.multiply(3);
time.toString('hh:mm:ss'); // 15:45:00
time.getMinutes(); // 45
time.toMinutes(); // 945
time.addHours(100);
// Without overflow
time.toString('hh:mm:ss'); // 15:45:00
// With overflow
time.toString('hh:mm:ss', true); // 115:45:00

https://github.com/rodrigogs/kairos

Unable to set following rules to warn

The following rules give a warning if set to warn

1:1  warning  Definition for rule 'you-dont-need-momentjs/endOf' was not found  you-dont-need-momentjs/endOf

'you-dont-need-momentjs/dayOfYear': 'warn',
'you-dont-need-momentjs/isoWeeksInYear': 'warn',
'you-dont-need-momentjs/startOf': 'warn',
'you-dont-need-momentjs/endOf': 'warn',
'you-dont-need-momentjs/fromNow': 'warn',
'you-dont-need-momentjs/daysInMonth': 'warn',
'you-dont-need-momentjs/isBefore': 'warn',
'you-dont-need-momentjs/isSame': 'warn',
'you-dont-need-momentjs/isAfter': 'warn',
'you-dont-need-momentjs/isBetween': 'warn',
'you-dont-need-momentjs/isLeapYear': 'warn',
'you-dont-need-momentjs/isDate': 'warn',

See also: Fecha

Fecha is another light alternative to Moment; might be a worthy addition to the list.

https://github.com/taylorhakes/fecha

It would be so incredible to provide codemod

😍

tc39-temporal

Comparisons should include an ES standard proposal:
https://github.com/tc39/proposal-temporal

What about timeago.js ?

What about timeago.js as alternative (2kb) ?
https://github.com/hustcc/timeago.js

Add Query -> is Valid section

Would be useful to have a showcase for testing if a date is valid.

Timezone support

You might mention that if you need to format dates for a timezone that's not that of the host then you can't use date-fns/native dates right now.

Day of Year breaks due to Daylight savings

Your Day Of Year Native code will fail between midnight and 1am during daylight savings.

My replacement was:

Math.floor( (new Date().setHours(2) - new Date(new Date().getFullYear(), 0, 0)) / 1000 / 60 / 60 / 24 );

which forces the time for the day.

Alternatively:

Math.floor( (Date.UTC(year, month, day) - Date.UTC(year, 0, 0)) / 1000 / 60 / 60 / 24 )

The opposite code is quite simple, too:

new Date(year, 0 , dayOfYear)

IsBefore with an offset

How would I achieve something like this in native javascript :

moment(viewingDay).isBefore(moment(), 'day');

If this is possible then I can fully ditch moment

Native Date format using toLocaleDateString

Hi, I really like this! thanks for your effort!

I Know it's not exactly the same, but i think you can add toLocaleDateString as an native option for date formatting. More in the link below:

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toLocaleDateString

Equivalent for moment.utc APIs

momentjs supports using it either in the local timezone or in the UTC timezone. But this repo only gives alternatives for the local timezone case. It would be great to have alternatives for the UTC case too.

Add fix when using `--fix` flag

It would be amazing to have the ability to have eslint automatically fix files that violate this plugin's rule. This would make migration to date-fns and other packages much easier.

Thoughts on adding getting long month names (and possibly day names)?

It's simple enough to hard code it of course but I ran into this cool answer on StackOverflow on getting the long month names via Intl:

https://stackoverflow.com/questions/47232534/how-to-get-a-list-of-month-names-in-javascript-using-intl

I wondered if it might be worth adding to this guide. It would be awesome to get long and short day names too if that is possible.

Just wanted to ask before digging into it and to have a reminder (as have to come back to it later).

eslint rule `no-moment-methods/seconds` only checked for attribute access using dot notation

moment().seconds();      // ×
moment()['seconds']();   // √

Feature Parity is missing durations

Durations are a standardized format and should be included.

• momentjs supports.
• date-fns does not officially, but there is a user-contributed workaround
• dayjs does not support
• luxon supports

How do I parse certain locale dates without MomentJS?

The example I have would be an input box where the user is allowed to type in a date with their preferred locale format or modify the date shown to them. I am showing German locale because it usually causes typical Date.parse() functions to fail because it doesn't know the month and day are swapped.

function deriveDateFormat(locale) {
  const isoString1 = '1979-02-03'; // example date!
  const isoString2 = '79-2-3'; // example date!

  const intlString = new Date(isoString1).toLocaleDateString(locale, { timeZone: 'UTC' }); // generate a formatted date
  const dateParts1 = isoString1.split('-'); // prepare to replace with pattern parts
  const dateParts2 = isoString2.split('-'); // prepare to replace with pattern parts

  return intlString
    .replace(dateParts1[2], 'DD')
    .replace(dateParts1[1], 'MM')
    .replace(dateParts1[0], 'YYYY')
    .replace(dateParts2[2], 'D')
    .replace(dateParts2[1], 'M')
    .replace(dateParts2[0], 'YY');
}

const myLocale = 'de-DE';
let d = new Date('2023-01-30T05:00:00.000Z');
let dateFormatted = d.toLocaleDateString(myLocale);
// 30.1.2023

// user changes input field
dateFormatted = '31.1.2023';

let nativeParsed = new Date(dateFormatted).toISOString();
// Invalid Date -- WRONG!

let dateParsed = moment(dateFormatted, deriveDateFormat(myLocale)).toISOString();
// 2023-01-31T05:00:00.000Z -- CORRECT!

I will add that this is just an example. Assume I do not know what the user's locale is until the time of execution. I am aware that I could manually convert this particular locale, but I am looking for a generic solution.

Linked Moment Tests don't support bugs argument?

In the README, there's a line that says It is mutable due to OOP APIs and non-pure functions, which cause bugs: with a link to https://github.com/moment/moment/blob/develop/src/test/moment/add_subtract.js#L244-L286

I'm looking at these tests and I can't seem to pin point why these tests might support the line which cause bugs. Sure, the API is a bit verbose and it is OOP vs pure, but I don't think it's buggy.

no mention of using Intl.DateTimeFormat

Intl.DateTimeFormat has some useful features would love to see some example compared to other libs

Enable coveralls

Add js-joda

Would you accept a PR that adds js-joda? If so, I could create one.

js-joda is an immutable date and time library for JavaScript that is very close to the java.time API. It is not just a wrapper around the native Date object, like most other libraries. The API has a domain-oriented design with classes for each of the different use cases, such as LocalDate, ZonedDateTime or Period. Actually, it is quite similar to the upcoming javascript temporal proposal.

implement eslint plugin

similar to https://github.com/you-dont-need/You-Dont-Need-Lodash-Underscore project...

Add js-joda

Please consider adding js-joda. It is amazing!

No mention of Luxon?

https://github.com/moment/luxon

It fully supports time zones (unlike date-fns), fully immutable and much smaller in size than momentjs.
It's the best in the market imo if you need timezones/ISO8601 support.