core-js

As advertising: the author is looking for a good job :)

It's documentation for the unstable core-js@3, if you looking documentation for core-js@2, please, check this branch.

Modular standard library for JavaScript. Includes polyfills for ECMAScript 5, 2015, 2016, 2017: promises, symbols, collections, iterators, typed arrays, many other features, ECMAScript proposals, some cross-platform WHATWG / W3C ECMAScript-related features and proposals like setImmediate. You can load only required features or use it without global namespace pollution.

Example:

import 'core-js'; // <- at the top of your entry point

Array.from(new Set([1, 2, 3, 2, 1]));          // => [1, 2, 3]
[1, [2, 3], [4, [5]]].flat(2);                 // => [1, 2, 3, 4, 5]
Promise.resolve(32).then(x => console.log(x)); // => 32

You can load only required features:

import 'core-js/features/array/from'; // <- at the top of your entry point
import 'core-js/features/array/flat'; // <- at the top of your entry point
import 'core-js/features/set';        // <- at the top of your entry point
import 'core-js/features/promise';    // <- at the top of your entry point

Array.from(new Set([1, 2, 3, 2, 1]));          // => [1, 2, 3]
[1, [2, 3], [4, [5]]].flat(2);                 // => [1, 2, 3, 4, 5]
Promise.resolve(32).then(x => console.log(x)); // => 32

Or use it without global namespace pollution:

import from from 'core-js-pure/features/array/from';
import flat from 'core-js-pure/features/array/flat';
import Set from 'core-js-pure/features/set';
import Promise from 'core-js-pure/features/promise';

from(new Set([1, 2, 3, 2, 1]));                // => [1, 2, 3]
flat([1, [2, 3], [4, [5]]], 2);                // => [1, 2, 3, 4, 5]
Promise.resolve(32).then(x => console.log(x)); // => 32

Usage

Basic

Installation:

// global version
npm i [email protected]
// version without global namespace pollution
npm i [email protected]
// bundled global version
npm i [email protected]

// Include all polyfills
require('core-js');

If you need already bundled version of core-js, use core-js-bundle npm package or a version of this package from CDN (minified version).

Warning: if you use core-js with the extension of native objects, load all core-js modules at the top of entry point of your application, otherwise, you can have conflicts.

CommonJS

You can require only needed modules, like in examples at the top of README.md. Available entry points for methods / constructors and namespaces: for example, core-js/es/array (core-js-pure/es/array) contains all ES Array features, core-js/es (core-js-pure/es) contains all ES features.

Caveats when using CommonJS API:

modules path is internal API, does not inject all required dependencies and can be changed in minor or patch releases. Use it only for a custom build and / or if you know what are you doing.
core-js is extremely modular and uses a lot of very tiny modules, because of that for usage in browsers bundle up core-js instead of usage loader for each file, otherwise, you will have hundreds of requests.

CommonJS and prototype methods without global namespace pollution

In the pure version, we can't pollute prototypes of native constructors. Because of that, prototype methods transformed to static methods like in examples above. babel runtime transformer also can't transform them. But with transpilers we can use one more trick - bind operator and virtual methods. Special for that, available /virtual/ entry points. Example:

import fill from 'core-js-pure/features/array/virtual/fill';
import findIndex from 'core-js-pure/features/array/virtual/find-index';

Array(10)::fill(0).map((a, b) => b * b)::findIndex(it => it && !(it % 8)); // => 4

// or

import { fill, findIndex } from 'core-js-pure/features/array/virtual';

Array(10)::fill(0).map((a, b) => b * b)::findIndex(it => it && !(it % 8)); // => 4

Babel

core-js integrated to some parts of babel:

`@babel/polyfill`

@babel/polyfill IS core-js and regenerator-runtime for generators and async functions, it's just 2 lines, so if you load @babel/polyfill - you load the full global version of core-js.

`@babel/runtime`

@babel/runtime simplifies work with core-js-pure. It automatically replaces usage of modern features from ECMAScript standard library to imports from the version of core-js without global namespace pollution, so instead of:

import from from 'core-js-pure/features/array/from';
import Set from 'core-js-pure/features/set';
import Promise from 'core-js-pure/features/promise';

from(new Set([1, 2, 3, 2, 1]));
Promise.resolve(32).then(x => console.log(x));

you can write just:

Array.from(new Set([1, 2, 3, 2, 1]));
Promise.resolve(32).then(x => console.log(x));

At this moment, it does not work with instance methods, only globals and statics.

`@babel/preset-env`

@babel/preset-env has useBuiltIns option, which optimizes work with polyfill. It works only with stable ECMAScript features, polyfills for ECMAScript proposals you should import separately.

useBuiltIns: 'entry' replaces import '@babel/polyfill' or import 'core-js' to import only required features for the target environment. So, for example, for enough modern target,

import 'core-js';

will be replaced to something like:

import 'core-js/modules/es.promise.finally';
import 'core-js/modules/es.string.pad-start';
import 'core-js/modules/es.string.pad-end';
// ...

useBuiltIns: 'usage' adds at the top of each file imports of polyfills for features used in this file, so for:

// first file:
var set = new Set();

// second file:
var array = Array.of(1, 2, 3);

if target contains old environments without support those ECMAScript features we will have:

// first file:
import 'core-js/modules/es.set';
var set = new Set();

// second file:
import 'core-js/modules/es.array.of';
var array = Array.of(1, 2, 3);

In this case, feature detection is not perfect. Also, import of polyfills not at the top of your entry point can cause problems.

Custom build

For some cases could be useful add a blacklist of features. core-js-builder package exports a function. This will conditionally include or exclude certain parts of core-js:

require('core-js-builder')({
  modules: ['es', 'esnext.reflect', 'web'],        // modules / namespaces
  blacklist: ['es.math', 'es.number.constructor'], // blacklist of modules / namespaces, by default - empty list
}).then(code => {
  // ...
}).catch(error => {
  // ...
});

Supported engines

Tested in:

Chrome 26+
Firefox 4+
Safari 5+
Opera 12+
Internet Explorer 6+ (sure, IE8- with ES3 limitations)
Edge
Android Browser 2.3+
iOS Safari 5.1+
PhantomJS 1.9 / 2.1
NodeJS 0.8+

...and it doesn't mean core-js will not work in other engines, they just have not been tested.

dsonet / core-js Goto Github PK

core-js's Introduction

core-js

As advertising: the author is looking for a good job :)

Index

Usage

Basic

CommonJS

Caveats when using CommonJS API:

CommonJS and prototype methods without global namespace pollution

Babel

@babel/polyfill

@babel/runtime

@babel/preset-env

Custom build

Supported engines

Features:

ECMAScript

ECMAScript: Object

ECMAScript: Function

ECMAScript: Array

ECMAScript: String and RegExp

ECMAScript: Number

ECMAScript: Math

ECMAScript: Date

ECMAScript: Promise

Unhandled rejection tracking

ECMAScript: Symbol

Caveats when using Symbol polyfill:

ECMAScript: Collections

Map

Set

WeakMap

WeakSet

Caveats when using collections polyfill:

ECMAScript: Typed Arrays

Caveats when using typed arrays polyfills:

ECMAScript: Reflect

ECMAScript proposals

Stage 4 proposals

Stage 3 proposals

Stage 2 proposals

Stage 1 proposals

Stage 0 proposals

Pre-stage 0 proposals

Web standards

setTimeout / setInterval

setImmediate

queueMicrotask

Iterable DOM collections

Iteration helpers

Missing polyfills

core-js's People

Contributors

Watchers

Recommend Projects

Recommend Topics

Recommend Org

`@babel/polyfill`

`@babel/runtime`

`@babel/preset-env`

Caveats when using `Symbol` polyfill: