Wondering what’s next for npm?Check out our public roadmap! »

    object-organizer
    TypeScript icon, indicating that this package has built-in type declarations

    1.2.1 • Public • Published

    object-organizer

    npm NPM

    Concept

    • You will be able to use an iterable object of all type or a plain object on almost all API of this library

    ex: Array, Plain object, Map, Set, Generator Iterable object ...

    • The library included essential apis necessary when development an application

    I think not need big library like the lodash or underscore when development most an application

    • Supports tree shaking for the application size of your project

    • Supports multiple browsers

    You will able to use array-organizer when for handling as only data of an array type

    Install

    npm i object-organizer

    API Documentation

    http://mohwa.github.io/object-organizer

    Support Platforms

    IE9 later, All modern browsers(Chrome, Safari, Edge ...), NodeJS(10.0.0 version later)

    Conversion API

    That apis will be convert given an iterable object or a plain object to certain an object

    import {
     toPlainObject,
     toMap,
     toSet,
     toSetAll,
     toArray,
     toArrayAll,
    } from 'object-organizer';
    
    toPlainObject(''); // {}
    toPlainObject('   '); // { '0': ' ', '1': ' ', '2': ' ' }
    toPlainObject('test'); // { '0': 't', '1': 'e', '2': 's', '3': 't' }
    toPlainObject([1, 2, 3]); // { '0': 1, '1': 2, '2': 3 }
    toPlainObject({ x: 1, y: 2, z: 3 }); // { x: 1, y: 2, z: 3 }
    toPlainObject({}); // {}
    toPlainObject([]); // {}
    toPlainObject(undefined); // {}
    toPlainObject(null); // {}
    toPlainObject(true); // {}
    
    toPlainObject(
     [1, 2, 3],
     function(v) {
       return { v, _this: this };
     },
     { x: 1 }
    ); // { '0': { v: 1, _this: { x: 1 } },'1': { v: 2, _this: { x: 1 } },'2': { v: 3, _this: { x: 1 } }}
    
    toMap(''); // Map {}
    toMap('   '); // Map { 0 => ' ', 1 => ' ', 2 => ' ' }
    toMap('test'); // Map { 0 => 't', 1 => 'e', 2 => 's', 3 => 't' }
    toMap([1, 2, 3]); // Map { 0 => 1, 1 => 2, 2 => 3 }
    toMap({ x: 1, y: 2, z: 3 }); // Map { 'x' => 1, 'y' => 2, 'z' => 3 }
    toMap({}); // Map {}
    toMap([]); // Map {}
    toMap(undefined); //Map {}
    toMap(null); // Map {}
    toMap(true); // Map {}
    
    toMap(
     [1, 2, 3],
     function(v) {
       return { v, _this: this };
     },
     { x: 1 }
    ); // Map { 0 => { v: 1, _this: { x: 1 } }, 1 => { v: 2, _this: { x: 1 } }, 2 => { v: 3, _this: { x: 1 } }}
    
    toSet(''); // Set {}
    toSet('   '); // Set { ' ' }
    toSet('test'); // Set { 't', 'e', 's' }
    toSet([1, 2, 3]); // Set { 1, 2, 3 }
    toSet({ x: 1, y: 2, z: 3 }); // Set { { k: 'x', v: 1 }, { k: 'y', v: 2 }, { k: 'z', v: 3 } }
    toSet({}); // Set {}
    toSet([]); // Set {}
    toSet(undefined); // Set {}
    toSet(null); // Set {}
    toSet(true); // Set {}
    
    toSet(
     [1, 2, 3],
     function(v) {
       return { v, _this: this };
     },
     { x: 1 }
    ); // Set {{ v: 1, _this: { x: 1 } },{ v: 2, _this: { x: 1 } },{ v: 3, _this: { x: 1 } }}
    
    toSetAll('1'); // Set { '1' }
    toSetAll(1); // Set { 1 }
    toSetAll(true); // Set { true }
    toSetAll(undefined); // Set { undefined }
    toSetAll(null); // Set { null }
    toSetAll(Symbol(3)); // Set { Symbol(3) }
    toSetAll(function() {}); // Set { [Function] }
    toSetAll(''); // Set { '' }
    toSetAll('  '); // Set { ' ' }
    toSetAll([1, 2, 3]); // Set { 1, 2, 3 }
    toSetAll({ x: 1, y: 2, z: 3 }); // Set { { k: 'x', v: 1 }, { k: 'y', v: 2 }, { k: 'z', v: 3 } }
    toSetAll({}); // Set {}
    toSetAll([]); // Set {}
    
    
    toArray(''); // []
    toArray('   '); // [ ' ', ' ', ' ' ]
    toArray('test'); // [ 't', 'e', 's', 't' ]
    toArray([1, 2, 3]); // [ 1, 2, 3 ]
    toArray({ x: 1, y: 2, z: 3 }); // [ { k: 'x', v: 1 }, { k: 'y', v: 2 }, { k: 'z', v: 3 } ]
    toArray({}); // []
    toArray([]); // []
    toArray(undefined); // []
    toArray(null); // []
    toArray(true); // []
    
    toArray(
     [1, 2, 3],
     function(v) {
       return { v, _this: this };
     },
     { x: 1 }
    ); // [{ v: 1, _this: { x: 1 } },{ v: 2, _this: { x: 1 } },{ v: 3, _this: { x: 1 } }]
    
    // toArrayAll converts an any element unlike a toArray
    toArrayAll('1'); // ['1']
    toArrayAll(1); // [1]
    toArrayAll(true); // [true]
    toArrayAll(undefined); // [undefined]
    toArrayAll(null); // [null]
    toArrayAll(Symbol(3)); // [Symbol(3)]
    toArrayAll(function(){}); // [[Function]]
    toArrayAll(''); // ['']
    toArrayAll('  '); // ['', '']
    toArrayAll([1, 2, 3]); // [1, 2, 3]
    toArrayAll({ x: 1, y: 2, z: 3 }); // [{ k: 'x', v: 1}, { k: 'y', v: 2}, { k: 'z', v: 3}]
    toArrayAll({}); // []
    toArrayAll([]); // []

    Copy API

    That apis will be used copy or deep-copy an iterable object or a plain object

    import {
     copy,
     deepCopy,
    } from 'object-organizer';
    
    1
    undefined
    null
    [Function: bound ]
    [ 11, 22, 33 ]
    { x: 1, y: 2 }
    Map { 'x' => 1, 'y' => 2 }
    {}
    
    copy(1); // 1
    copy(undefined); // undefined
    copy(null); // null
    copy(function() {}); // ƒ () {}
    copy([11, 22, 33]); // [11, 22, 33]
    copy({ x: 1, y: 2 }); // { x: 1, y: 2 }
    
    copy(
     new Map([
       ['x', 1],
       ['y', 2],
     ])
    ); // Map { 'x' => 1, 'y' => 2 }
    
    copy(new Set([1, 2, 3])); // Set { 1, 2, 3 } 
    
    copy(
     (function*() {
       yield 1;
     })()
    ); // {}
    
    deepCopy({ x: { y: { x: { y: function() {} } } } }); // { x: { y: { x: [Object] } } }
    deepCopy({ x: { y: new Map([['x', { x: { y: function() {}, z: new Set([1, 2, 3]) } }]]) } }); // { x: { y: Map { 'x' => [Object] } } } 

    Main API

    You will be able to use for add or remove or search every element of iterable object via various apis

    import {
      assign,
      find,
      asc,
      desc,
      insert,
      replace,
      remove,
      includes,
      deepFind,
      ascBy,
      descBy,
      forEach,
      indexOf,
      lastIndexOf,
      keys,
      values,
      join,
      size,
      hasProp,
      hasInstanceOf,
      unshift,
      push,
    } from 'object-organizer';
    
    assign([1, 2, 3], 33, 33, 44); // [ 1, 2, 3, 33, 33, 44 ]
    assign(new Set([1, 2, 3]), 33, 44, 55); // Set { 1, 2, 3, 33, 44, 55 }
    assign([1, 2, 3], { x: 1 }); // [ 1, 2, 3, { k: 'x', v: 1 } ]
    
    find(['1', 2, 3], v => typeof v === 'number'); // 2
    find({ x: 11, y: 22, z: 33 }, ({ v }) => typeof v === 'number'); // { k: 'x', v: 11 }
    
    forEach('  ', (v, k) => console.log(v)); // '', ''
    forEach('test', (v, k) => console.log(v)); // 't', 'e', 's', 't'
    forEach([1, 2, 3], (v, k) => console.log(v)); // 1, 2, 3
    forEach({ x: 1, y: 2, z: 3 }, (v) => console.log(v)); // 1, 2, 3
    forEach(new Map([['x', 1], ['y', 2], ['z', 3]]), (v) => console.log(v)); // 1, 2, 3
    forEach(new Set([1, 2, 3]), (v) => console.log(v)); // 1, 2, 3
    
    indexOf([1, 2, 3], v => v === 2); // 1
    indexOf([1, 2, 3], v => v === 2, 2); // -1
    indexOf({ x: 1, y: 2, z: 3 }, ({ k, v }) => v === 2, 2); // -1
    
    lastIndexOf([1, 2, 3], v => v === 2); // 1
    lastIndexOf({ x: 1, y: 2, yy: { zz: 3 }, zz: 44 }, ({ k, v }) => v === 44, 2); // -1
    
    join([1, 2, 3], '-') // '1-2-3'
    join({ x: 1, y: 2, z: 3 }, '-') // '1-2-3'
    
    keys([1, , 3]); // [0, 1, 2]
    keys({ x: 1, y: 2, z: 3 }); // ['x', 'y', 'z']
    
    values([1, , 3]); // [1, undefined, 3]
    values({ x: 1, y: 2, z: 3 }); // [1, 2, 3]
    
    // In result c is container object of y property
    deepFind([{ x: { xx: { y: 3, z: 'A' } } }], v => typeof v === 'number'); // { c: { y: 3, z: 'A' }, k: 'y', v: 3, origin: [{ ... }] }
    
    // Will be found a 2 from an array object 
    includes([1, 2, 3], v => v === 2); // true
    includes({ x: 1, y: 2, yy: { zz: 3 } }, ({ k, v }) => v === 44); // false
    
    asc(['d', null, 0xff, true, { x: 1 }, 'ee', new Map(), 't', 0]); // [null, { x: 1 }, {}, 0, true, 'd', 't', 'ee', 255]
    asc({ x: 'd', y: null, z: 0xff }); // [null, 'd', 255]
    
    desc([5, 3, 4, 6, 1, 2]); // [6, 5, 4, 3, 2, 1]
    // Will be sorted after convert 0xff to number 255
    desc(['d', true, undefined, 0xff, 'ee', [], 2e4, () => {}, 't', 0]); // [20000, 255, 'ee', 't', 'd', true, Array(0), f (), 0, undefined]
    
    // Will be ascending based y property
    ascBy([{ x: 1, y: 11 }, { x: 2, y: 22 }, { x: 3, y: 33 }], 'y'); // [{ ...y: 11 }, { ...y: 22 }, { ...y: 33 }]
    descBy([{ x: 1, y: 11 }, { x: 2, y: 22 }, { x: 3, y: 33 }], 'y'); // [{ ...y: 33 }, { ...y: 22 }, { ...y: 11 }]
     
    // Will be inserted a 22 to index 1
    insert([1, 2, 3, 4], 1, 22); // [1, 22, 2, 3, 4]
    // Will be inserted a 22 to index 1 and add 'ADD'
    replace([1, 2, 3, 4], 2, 33, 'ADD'); // [1, 2, 33, 'ADD', 4]
    
    remove(['1', 2, 3, 4], v => typeof v === 'number'); // ['1']
    remove(['1', 2, 3, 4], v => typeof v === 'string'); // [2, 3, 4]
    remove(new Set(['1', 2, 3, 4]), v => typeof v === 'string'); // Set { 2, 3, 4 }
    
    unshift([], 11, 22, 33); // [ 11, 22, 33 ]
    unshift([1, 2, 3], 11, 22, 33); // [ 11, 22, 33, 1, 2, 3 ]
    
    push([], 11, 22, 33); // [ 11, 22, 33 ]
    push([1, 2, 3], 11, 22, 33); // [ 1, 2, 3, 11, 22, 33 ]
    
    size(new Map([['x', 1]])) // 1
    
    hasProp({ x: { y: { z: () => {} } } }, 'x') // true
    
    const hasInstanceOfConstructor = function() {};
    
    hasInstanceOf(new hasInstanceOfConstructor(), hasInstanceOfConstructor); // true

    Deep Dive API

    That apis will be used a deep based a native functions

    import {
      deepFreeze,
      deepSeal,
      deepPreventExtensions,
      deepHasProp,
      deepHasExtensible,
      deepHasFrozen,
      deepHasSealed
    } from 'object-organizer';
    
    const freezeObject = { x: { y: { z: () => {} } } };
    deepFreeze(freezeObject);
    
    console.log(Object.isFrozen(freezeObject.x.y.z)); // true
    
    const sealObject = { x: { y: { z: () => {} } } };
    deepSeal(sealObject);
    
    console.log(Object.isSealed(sealObject.x.y.z)); // true
    
    const extensibleObject = { x: { y: { z: () => {} } } };
    deepPreventExtensions(extensibleObject);
    
    console.log(Object.isExtensible(extensibleObject.x.y.z)); // false
    
    const deepHasPropObject = { x: { y: { z: () => {}, x: { y: { zz: 1 } } } } };
    console.log(deepHasProp(deepHasPropObject, 'zz')); // true
    
    const deepHasExtensibleObject = { x: { y: { z: () => {} } } };
    deepPreventExtensions(deepHasExtensibleObject.x.y.z); // true
    
    console.log(deepHasExtensible(deepHasExtensibleObject.x.y.z)); // false
    
    const deepHasFrozenObject = { x: { y: { z: () => {} } } };
    deepFreeze(deepHasFrozenObject.x.y.z); // true
    
    console.log(deepHasFrozen(deepHasFrozenObject));
    
    const deepHasSealedObject = { x: { y: { z: () => {} } } };
    deepSeal(deepHasSealedObject.x.y.z); // true
    
    console.log(deepHasSealed(deepHasSealedObject.x.y.z)); // true

    Other API

    import {
      entries,
      of,
      findIndex,
    } from 'object-organizer';
     
    entries({ x: 1, y: 2, z: new Map([['x', 1]]) }); // [ [ 'x', 1 ], [ 'y', 2 ], [ 'z', Map { 'x' => 1 } ] ]
    
    of(1, 2, 3); // [ 1, 2, 3 ]
    
    findIndex(['1', 2, 3], v => typeof v === 'number'); // 1
    findIndex({ x: 11, y: 22, z: 33 }, ({ v }) => v === 33); // 2

    Install

    npm i object-organizer

    DownloadsWeekly Downloads

    17

    Version

    1.2.1

    License

    MIT

    Unpacked Size

    216 kB

    Total Files

    9

    Last publish

    Collaborators

    • avatar