es6-harmony

    0.2.4 • Public • Published

    NPM version NPM total downloads License

    ES6 Harmony

    Provides an equivalent implementation of ES6(Harmony) in pure ES5 and creates an ES6 environment for old browsers and JavaScript Engines.

    ES6 shims in pure ES5.

    Install

    NPM

    Install it from npm and require it before any other modules:

    $ npm install --save es6-harmony
    var ES6 = require("es6-harmony");

    CDN

    If you prefer CDN, then just insert it into your HTML page on the top of other scripts:

    <script src="https://cdn.jsdelivr.net/npm/es6-harmony/dist/es6-harmony.min.js"></script>

    Examples

    "use strict";
     
    var ES6 = require("es6-harmony");
     
    var arr = [1, 2, 3];
     
    ES6.forOf(arr, function (v) {
        console.log(v);
    });
    // 1
    // 2
    // 3
     
    console.log(Array.from("Bar")); // [ 'B', 'a', 'r' ]
     
    console.log(Array.of(1, 2, 3)); // [ 1, 2, 3 ]
     
    console.log(Array.of.call(Object, 1, 2, 3)); // { [Number: 3] '0': 1, '1': 2, '2': 3, length: 3 }
     
    console.log([1, 2, 3].fill("Bar")); // [ 'Bar', 'Bar', 'Bar' ]
     
    console.log([1, 2, "bar"].find(function (v) {
        return typeof v === "number";
    }));
    // 1
     
    console.log([1, 2, "bar"].findIndex(function (v) {
        return typeof v === "number";
    }));
    // 0
     
    var it = arr.entries();
     
    console.log(it.next()); // { done: false, value: [ 0, 1 ] }
    console.log(it.next()); // { done: false, value: [ 1, 2 ] }
    console.log(it.next()); // { done: false, value: [ 2, 3 ] }
    console.log(it.next()); // { done: true, value: undefined }
     
     
    var map = new Map([[1, 2], ["bar", "baz"]]);
     
    console.log(map.size); // 2
     
    map.set(0, {});
    map.set(NaN, Object);
     
    console.log(map.has(NaN)); // true
    console.log(map.has(-0)); // true
     
    it = map.keys();
     
    console.log(it.next()); // { done: false, value: 1 }
    console.log(it.next()); // { done: false, value: 'bar' }
    console.log(it.next()); // { done: false, value: NaN }
     
    ES6.forOf(map, function (v) {
        console.log(v);
    });
    // [ 1, 2 ]
    // [ 'bar', 'baz' ]
    // [ 0, {} ]
    // [ NaN, [Function: Object] ]
     
    var set = new Set([1, 2, "bar"]);
     
    console.log(set.size); // 3
     
    set.add(-0);
    set.add(NaN);
     
    console.log(set.has(0)); // true
    console.log(set.has(NaN)); // true
     
    it = set.values();
     
    console.log(it.next()); // { done: false, value: 1 }
    console.log(it.next()); // { done: false, value: 2 }
    console.log(it.next()); // { done: false, value: 'bar' }
     
    ES6.forOf(set, function (v) {
        console.log(v);
    });
    // 1
    // 2
    // bar
    // -0
    // NaN
     
    var wm = new WeakMap();
    wm.set(Object, "object");
    wm.set({}, "normal object");
     
    console.log(wm.has(Object)); // true
    console.log(wm.has({})); // false
     
    var ws = new WeakSet();
     
    ws.add(Object);
    ws.add(Math);
     
    console.log(ws.has(Math)); // true
    console.log(ws.has(new Object())); // false
     
    console.log(Number.isNaN(NaN)); // true
    console.log(Number.isFinite(Infinity)); // false
    console.log(Number.isInteger(-11)); // true
    console.log(Number.isSafeInteger(Math.pow(2, 53) - 1)); // true
     
    console.log(Object.is(-0, 0)); // false
    console.log(Object.is(NaN, NaN)); // true
     
    var a = {};
    var b = {};
     
    Object.setPrototypeOf(a, b);
    console.log(Object.getPrototypeOf(a) === b); // true
     
    console.log(Object.assign({}, "bar")); // { '0': 'b', '1': 'a', '2': 'r' }
     
    var sym1 = Symbol("bar");
    var sym2 = Symbol("baz");
     
    a[sym1] = "This is symbol property";
    a[sym2] = "This is another symbol property";
     
    var allSymbols = Object.getOwnPropertySymbols(a);
     
    console.log(allSymbols.length); // 2
    console.log(allSymbols[0] === a); // false
    console.log(allSymbols[1] === b); // false
     
    console.log(String.fromCodePoint(0xFFFF, 0x10FFFF).length); // 3
     
    sym1 = Symbol("BAZ");
    sym2 = Symbol.for("BAZ");
     
    console.log(sym1 === Symbol("BAZ")); // false
    console.log(sym2 === Symbol.for("BAZ")); // true
     
    var obj = {
        length: 2,
        0: "a",
        1: 122
    };
     
    it = Array.prototype[Symbol.iterator].call(obj); // { done: false, value: 'a' }
     
    console.log(ES6.spreadOperator([]).spread("Bar", [1, 2, 3]).add(1, 2, 4).array()); // [ 'B', 'a', 'r', 1, 2, 3, 1, 2, 4 ]
     
    function sumArgs() {
        return Array.prototype.reduce.call(arguments, function (acc, currV) {
            return acc + currV;
        }, 0);
    }
     
    console.log(ES6.spreadOperator(sumArgs).spread([1, 2, 3]).add(11, 22).call()); // 39
     
    function Box(width, height) {
        this.width = width;
        this.height = height;
    }
     
    console.log(ES6.spreadOperator(Box).spread([1, 2.22]).new()); // Box { width: 1, height: 2.22 }
     
    console.log(it.next()); // { done: false, value: 'a' }
     
    var promise = new Promise(function (resolve, reject) {
        setTimeout(resolve, 0, 100);
    });
     
    promise.then(function (value) {
        console.log(value);
        return new Promise(function (resolve, reject) {
            setTimeout(resolve, 0, 110);
        });
    }).then(function (value) {
        console.log(value);
        return {
            then: function (resolve, reject) {
                setTimeout(reject, 0, "Error");
            }
        }
    }).catch(console.log.bind(console));
     
    // 100
    // 110
    // Error

    Implemented

    • Array

      • Array.from()
      • Array.of()
      • Array.prototype.fill()
      • Array.prototype.find()
      • Array.prototype.findIndex()
      • Array.prototype.entries()
      • Array.prototype.keys()
      • Array.prototype.copyWithin()
      • Array.prototype.concat() (ES6 version, addition of @@isConcatSpreadable support)
      • Array.prototype[@@iterator]
    • Map

      • Map.prototype.size
      • Map.prototype.set()
      • Map.prototype.get()
      • Map.prototype.has()
      • Map.prototype.clear()
      • Map.prototype.delete()
      • Map.prototype.entries()
      • Map.prototype.forEach()
      • Map.prototype.keys()
      • Map.prototype.values()
      • Map.prototype[@@iterator]()
      • Map.prototype[@@toStringTag]()
    • Set

      • Set.prototype.size
      • Set.prototype.add()
      • Set.prototype.clear()
      • Set.prototype.delete()
      • Set.prototype.entries()
      • Set.prototype.forEach()
      • Set.prototype.has()
      • Set.prototype.keys()
      • Set.prototype.values()
      • Set.prototype[@@iterator]()
      • Set.prototype[@@toStringTag]()
    • WeakMap

      • WeakMap.prototype.delete()
      • WeakMap.prototype.get()
      • WeakMap.prototype.has()
      • WeakMap.prototype.set()
      • WeakMap.prototype[@@toStringTag]()
    • WeakSet

      • WeakSet.prototype.add()
      • WeakSet.prototype.delete()
      • WeakSet.prototype.has()
      • WeakSet.prototype[@@toStringTag]()
    • Number

      • Number.isNaN()
      • Number.isFinite()
      • Number.isInteger()
      • Number.parseInt()
      • Number.parseFloat()
      • Number.EPSILON
      • Number.MAX_SAFE_INTEGER
      • Number.MIN_SAFE_INTEGER
      • Number.isSafeIntger()
    • Object

      • Object.is()
      • Object.setPrototypeOf() (It assumes that Object.prototype.__proto__ accessor property already exists)
      • Object.assign()
      • Object.getOwnPropertySymbols
      • Object.prototype.toString() (ES6 version, addition of @@toStringTag support)
    • Promise

      • Promise.all()
      • Promise.race()
      • Promise.reject()
      • Promise.resolve()
      • Promise.prototype.then()
      • Promise.prototype.catch()
    • String

      • String.fromCodePoint()
      • String.prototype.codePointAt()
      • String.prototype.startsWith()
      • String.prototype.endsWith()
      • String.prototype.includes()
      • String.prototype.repeat()
    • Symbol

      • Symbol.for()
      • Symbol.keyFor()
      • Symbol.iterator
      • Symbol.hasInstance
      • Symbol.isConcatSpreadable
      • Symbol.toStringTag
      • Symbol.prototype.toString()
      • Symbol.prototype.valueOf()

    Not Yet Implemented

    Some features are not yet implemented, but can be implemented safely. Click here to see those features.

    Limitation

    Some ES6 features can not be implemented in ES5 natively like spread operator, for..of loop, ES6 version of instanceOf operator etc. So this module exports an object named ES6 globally, that provides some approximate equivalent implementation of those features.

    ES6 Object

    This object provides,

    • isSymbol() (It can be used as equivalent API for typeof symbol === 'symbol')
    • instanceOf() (Provides ES6 version of instanceOf operator)
    • forOf() (This method behaves exactly same as for...of loop)
    • spreadOperator (Gives same functionality of the spread operator)

    Others utility methods,

    • isMap
    • isSet
    • isWeakMap
    • isWeakSet
    • isPromise

    Contributing

    Your PRs and stars are always welcome.

    Please, try to follow:

    • Clone the repository.
    • Checkout develop branch.
    • Install dependencies.
    • Add your new features or fixes.
    • Build the project.
    $ git clone https://github.com/rousan/es6-harmony.git
    cd es6-harmony
    $ git checkout develop
    $ npm i
    $ npm run build

    Install

    npm i es6-harmony

    DownloadsWeekly Downloads

    5

    Version

    0.2.4

    License

    MIT

    Last publish

    Collaborators

    • rousan