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

    json-merger
    TypeScript icon, indicating that this package has built-in type declarations

    1.1.5 • Public • Published

    json-merger

    Merge JSON (or YAML) files and objects with operations like $import $remove $replace $merge and more.

    Table of Contents:

    API

    .mergeFile(file: string, config?: Config)

    javascript

    var jsonMerger = require("json-merger");
    var result = jsonMerger.mergeFile("a.json");

    a.json:

    {
      "$merge": {
        "source": {
          "$import": "b.json"
        },
        "with": {
          "prop1": {
            "$replace": {
              "prop1a": "this will replace b.json's property prop1"
            }
          },
          "prop2": {
            "prop2a": "this will merge with b.json's property prop2"
          }
        }
      }
    }

    b.json:

    {
      "prop1": {
        "prop1b": "will be replaced"
      },
      "prop2": {
        "prop2b": "will be merged"
      }
    }

    result

    {
      "prop1": {
        "prop1a": "this will replace b.json's property prop1"
      },
      "prop2": {
        "prop2a": "this will merge with b.json's property prop2",
        "prop2b": "will be merged"
      }
    }

    .mergeFiles(files: string[], config?: Config)

    javascript

    var jsonMerger = require("json-merger");
    var result = jsonMerger.mergeFiles(["a.json", "b.json"]);

    a.json:

    {
      "a": "some value"
    }

    b.json:

    {
      "b": "some other value"
    }

    result

    {
      "a": "some value",
      "b": "some other value"
    }

    .mergeObject(object: object, config?: Config)

    javascript

    var jsonMerger = require("json-merger");
    
    var object = {
      a: {
        aa: "some value",
      },
      b: {
        $import: "b.json",
      },
    };
    
    var result = jsonMerger.mergeObject(object);

    b.json:

    {
      "bb": "some other value"
    }

    result

    {
      "a": {
        "aa": "some value"
      },
      "b": {
        "bb": "some other value"
      }
    }

    .mergeObjects(objects: object[], config?: Config)

    javascript

    var jsonMerger = require("json-merger");
    
    var object1 = {
      a: [1, 1, 1, 1],
    };
    
    var object2 = {
      a: [2, 2],
    };
    
    var result = jsonMerger.mergeObjects([object1, object2]);

    result

    {
      "a": [2, 2, 1, 1]
    }

    Merger(config?: Config)

    The actual Merger class is also exported. The other exports are just shortcut methods.

    Using one Merger instance has some performance advantages because it will cache previously loaded and processed files.

    javascript

    var Merger = require("json-merger").Merger;
    
    var merger = new Merger();
    
    // the first call will load and process "a.json"
    var result1 = merger.mergeFile("a.json");
    
    // the second call will return the cached result
    var result2 = merger.mergeFile("a.json");
    
    // clear the caches
    merger.clearCaches();

    Config

    interface Config {
      cwd?: string;
      errorOnFileNotFound?: boolean;
      errorOnRefNotFound?: boolean;
      operationPrefix?: string;
      params?: object;
      stringify?: boolean | "pretty";
      defaultArrayMergeOperation: "combine" | "replace" | "concat";
    }

    cwd: string

    The current working directory when importing files. Defaults to process.cwd().

    errorOnFileNotFound: boolean

    Set this property to false to disable throwing errors when an imported file does not exist.

    errorOnRefNotFound: boolean

    Set this property to false to disable throwing errors when an JSON pointer or JSON path does not exist.

    operationPrefix: string

    Use this property to override the prefix to indicate a property is an operation like $import. The default prefix is $but it is possible to change this to for example@to use keywords like@import.

    params: object

    Object that will be available in $expression operations as $params variable.

    stringify: boolean | "pretty"

    Set this property to true to stringify the JSON result. Set the property to "pretty" if the output should be pretty printed.

    defaultArrayMergeOperation: "combine" | "replace" | "concat"

    Set this property to override default merge operation. Default value is set to "combine". Possible values are:

    Operations

    $import

    Use $import to import other JSON or YAML files.

    Files imported with $import are processed before the result is returned.

    {
      "$import": "a.json"
    }

    JSON reference syntax is supported. The following example will import the first array item from the someArray property in a.json.

    {
      "$import": "a.json#/someArray/0"
    }

    When defined as an array, $import will process and merge the files in order before returning the result.

    {
      "$import": ["a.json", "b.yaml", "c.json"]
    }

    When importing a file it is also possible to provide a different $params object. Setting this property will override the Config.params property.

    {
      "$import": {
        "path": "a.json",
        "params": {
          "prop": "some value that will be available in a.json as $params.prop"
        }
      }
    }

    The object syntax is also supported in an array.

    {
      "$import": [
        {
          "path": "a.json",
          "params": {
            "prop": "value1"
          }
        },
        {
          "path": "a.json",
          "params": {
            "prop": "value2"
          }
        }
      ]
    }

    Use $include to process a file in the current scope.

    $merge

    Use the $merge operation to merge objects and arrays.

    javascript

    var result = jsonMerger.mergeFile("a.json");

    a.json

    {
      "$merge": {
        "source": {
          "a": {
            "aa": "some value"
          }
        },
        "with": {
          "a": {
            "bb": "some other value"
          }
        }
      }
    }

    result

    {
      "a": {
        "aa": "some value",
        "bb": "some other value"
      }
    }

    Merging with other files

    The $merge operation is often used with the $import operation to merge other files from within the JSON itself.

    javascript

    var result = jsonMerger.mergeFile("a.json");

    a.json

    {
      "$merge": {
        "source": {
          "$import": "b.json"
        },
        "with": {
          "a": {
            "bb": "some other value"
          }
        }
      }
    }

    b.json

    {
      "a": {
        "aa": "some value"
      }
    }

    result

    {
      "a": {
        "aa": "some value",
        "bb": "some other value"
      }
    }

    $remove

    Use the $remove operation to remove properties and array items.

    Remove object properties

    javascript

    var result = jsonMerger.mergeFiles(["a.json", "b.json"]);

    a.json

    {
      "prop1": {
        "prop1a": "some value"
      },
      "prop2": {
        "prop2a": "some other value"
      }
    }

    b.json

    {
      "prop2": {
        "$remove": true
      }
    }

    result

    {
      "prop1": {
        "prop1a": "some value"
      }
    }

    Remove array items

    javascript

    var result = jsonMerger.mergeFiles(["a.json", "b.json"]);

    a.json

    {
      "someArray": [1, 2, 3]
    }

    b.json

    {
      "someArray": [
        {
          "$remove": true
        },
        {
          "$remove": true
        }
      ]
    }

    result

    {
      "someArray": [3]
    }

    $replace

    Use the $replace operation to replace properties and array items.

    Replace object properties

    javascript

    var result = jsonMerger.mergeFiles(["a.json", "b.json"]);

    a.json

    {
      "prop1": {
        "prop1a": "some value"
      },
      "prop2": {
        "prop2a": "some other value"
      }
    }

    b.json

    {
      "prop2": {
        "$replace": {
          "prop2b": "replaced value"
        }
      }
    }

    result

    {
      "prop1": {
        "prop1a": "some value"
      },
      "prop2": {
        "prop2b": "replaced value"
      }
    }

    Replace array items

    javascript

    var result = jsonMerger.mergeFiles(["a.json", "b.json"]);

    a.json

    {
      "someArray": [
        {
          "a": 1
        },
        {
          "b": 2
        }
      ]
    }

    b.json

    {
      "someArray": [
        {
          "$replace": {
            "c": 3
          }
        }
      ]
    }

    result

    {
      "someArray": [
        {
          "c": 3
        },
        {
          "b": 2
        }
      ]
    }

    $concat

    Use the $concat operation to concatenate two arrays.

    javascript

    var result = jsonMerger.mergeFiles(["a.json", "b.json"]);

    a.json

    {
      "someArray": [1]
    }

    b.json

    {
      "someArray": {
        "$concat": [2]
      }
    }

    result

    {
      "someArray": [1, 2]
    }

    $combine

    Use the $combine operation to combine two arrays.

    javascript

    var result = jsonMerger.mergeFiles(["a.json", "b.json"]);

    a.json

    {
      "someArray": [1, 2, 3]
    }

    b.json

    {
      "someArray": {
        "$combine": [3, 3]
      }
    }

    result

    {
      "someArray": [3, 3, 3]
    }

    $append

    Use the $append operation to append an item to an array.

    javascript

    var result = jsonMerger.mergeFiles(["a.json", "b.json"]);

    a.json

    {
      "someArray": [1, 2, 3]
    }

    b.json

    {
      "someArray": [
        {
          "$append": 4
        }
      ]
    }

    result

    {
      "someArray": [1, 2, 3, 4]
    }

    $prepend

    Use the $prepend operation to prepend an item to an array.

    javascript

    var result = jsonMerger.mergeFiles(["a.json", "b.json"]);

    a.json

    {
      "someArray": [1, 2, 3]
    }

    b.json

    {
      "someArray": [
        {
          "$prepend": 4
        }
      ]
    }

    result

    {
      "someArray": [4, 1, 2, 3]
    }

    $insert

    Use the $insert operation to insert an item to an array.

    javascript

    var result = jsonMerger.mergeFiles(["a.json", "b.json"]);

    a.json

    {
      "someArray": [1, 2, 3]
    }

    b.json

    {
      "someArray": [
        {
          "$insert": {
            "index": 1,
            "value": 4
          }
        }
      ]
    }

    result

    {
      "someArray": [1, 4, 2, 3]
    }

    Insert as last item

    Set $insert.index to - to insert an item at the end of the array.

    javascript

    var result = jsonMerger.mergeFiles(["a.json", "b.json"]);

    a.json

    {
      "someArray": [1, 2, 3]
    }

    b.json

    {
      "someArray": [
        {
          "$insert": {
            "index": "-",
            "value": 4
          }
        }
      ]
    }

    result

    {
      "someArray": [1, 2, 3, 4]
    }

    Insert before the last item

    A negative $insert.index can be used, indicating an offset from the end of the array.

    javascript

    var result = jsonMerger.mergeFiles(["a.json", "b.json"]);

    a.json

    {
      "someArray": [1, 2, 3]
    }

    b.json

    {
      "someArray": [
        {
          "$insert": {
            "index": -1,
            "value": 4
          }
        }
      ]
    }

    result

    {
      "someArray": [1, 2, 4, 3]
    }

    $match

    Use the $match operation to search for a specific array item and merge with that item.

    Match by index

    Use $match.index to match an array item by index.

    javascript

    var result = jsonMerger.mergeFiles(["a.json", "b.json"]);

    a.json

    {
      "someArray": [1, 2, 3]
    }

    b.json

    {
      "someArray": [
        {
          "$match": {
            "index": 1,
            "value": 4
          }
        }
      ]
    }

    result

    {
      "someArray": [1, 4, 3]
    }

    Match by JSON pointer

    Use $match.path to match an array item with a JSON pointer.

    javascript

    var result = jsonMerger.mergeFiles(["a.json", "b.json"]);

    a.json

    {
      "someArray": [1, 2, 3]
    }

    b.json

    {
      "someArray": [
        {
          "$match": {
            "path": "/1",
            "value": 4
          }
        }
      ]
    }

    result

    {
      "someArray": [1, 4, 3]
    }

    Match by JSON path query

    Use $match.query to match an array item with a JSON path query. The following example will search for an array item containing the value 2 and merge it with the value 4.

    javascript

    var result = jsonMerger.mergeFiles(["a.json", "b.json"]);

    a.json

    {
      "someArray": [1, 2, 3]
    }

    b.json

    {
      "someArray": [
        {
          "$match": {
            "query": "$[?(@ == 2)]",
            "value": 4
          }
        }
      ]
    }

    result

    {
      "someArray": [1, 4, 3]
    }

    $move

    Use the $move operation to move an array item.

    javascript

    var result = jsonMerger.mergeFiles(["a.json", "b.json"]);

    a.json

    {
      "someArray": [1, 2, 3]
    }

    b.json

    {
      "someArray": [
        {
          "$move": 1
        }
      ]
    }

    result

    {
      "someArray": [2, 1, 3]
    }

    Move a matched array item

    Use the $match operation in conjunction with the $move operation to move a specific array item.

    javascript

    var result = jsonMerger.mergeFiles(["a.json", "b.json"]);

    a.json

    {
      "someArray": [1, 2, 3]
    }

    b.json

    {
      "someArray": [
        {
          "$match": {
            "index": 0,
            "value": {
              "$move": 1
            }
          }
        }
      ]
    }

    result

    {
      "someArray": [2, 1, 3]
    }

    Move a matched array item to the end

    Use - as $move.index value to move an array item to the end.

    javascript

    var result = jsonMerger.mergeFiles(["a.json", "b.json"]);

    a.json

    {
      "someArray": [1, 2, 3]
    }

    b.json

    {
      "someArray": [
        {
          "$match": {
            "index": 0,
            "value": {
              "$move": "-"
            }
          }
        }
      ]
    }

    result

    {
      "someArray": [2, 3, 1]
    }

    Move and merge a matched array item

    Use $move.value to not only move the item but also merge it with a value.

    javascript

    var result = jsonMerger.mergeFiles(["a.json", "b.json"]);

    a.json

    {
      "someArray": [
        {
          "a": 1
        },
        {
          "a": 2
        },
        {
          "a": 3
        }
      ]
    }

    b.json

    {
      "someArray": [
        {
          "$match": {
            "query": "$[?(@.a == 3)]",
            "value": {
              "$move": {
                "index": 0,
                "value": {
                  "b": 3
                }
              }
            }
          }
        }
      ]
    }

    result

    {
      "someArray": [
        {
          "a": 3,
          "b": 3
        },
        {
          "a": 1
        },
        {
          "a": 2
        }
      ]
    }

    $select

    Use the $select operation to select one or multiple values.

    Be careful not to create an endless loop by selecting a parent property.

    Select by JSON pointer

    More information about JSON pointers can be found in the JSON pointer specification.

    javascript

    var result = jsonMerger.mergeFile("a.json");

    a.json

    {
      "prop": {
        "$select": "/otherProp"
      },
      "otherProp": "Should be the value of prop"
    }

    result

    {
      "prop": "Should be the value of prop",
      "otherProp": "Should be the value of prop"
    }

    Use $select.query to select by JSON path query

    More information about JSON path queries can be found in the JSON path documentation.

    javascript

    var result = jsonMerger.mergeFile("a.json");

    a.json

    {
      "prop": {
        "$select": {
          "query": "$.someArray[*]"
        }
      },
      "someArray": [1, 2, 3]
    }

    result

    {
      "prop": 1,
      "someArray": [1, 2, 3]
    }

    Use $select.multiple to select multiple values

    javascript

    var result = jsonMerger.mergeFile("a.json");

    a.json

    {
      "prop": {
        "$select": {
          "query": "$.someArray[?(@ < 3)]",
          "multiple": true
        }
      },
      "someArray": [1, 2, 3]
    }

    result

    {
      "prop": [1, 2]
    }

    Use $select.from to select from an object

    javascript

    var result = jsonMerger.mergeFile("a.json");

    a.json

    {
      "prop": {
        "$select": {
          "from": {
            "$import": "b.json"
          },
          "path": "/someArray/2"
        }
      }
    }

    b.json

    {
      "someArray": [1, 2, 3]
    }

    result

    {
      "prop": 3
    }

    $repeat

    Use the $repeat operation to repeat a value.

    Repeat with $repeat.to

    operation

    {
      "$repeat": {
        "from": 1,
        "to": 4,
        "value": "repeat"
      }
    }

    result

    ["repeat", "repeat", "repeat"]

    Repeat with $repeat.through

    The current value is available on the scope as $repeat.value variable.

    operation

    {
      "$repeat": {
        "from": 1,
        "through": 4,
        "value": {
          "$expression": "$repeat.value"
        }
      }
    }

    result

    [1, 2, 3, 4]

    Repeat with $repeat.step

    operation

    {
      "$repeat": {
        "from": 0,
        "through": 10,
        "step": 5,
        "value": {
          "$expression": "$repeat.value"
        }
      }
    }

    result

    [0, 5, 10]

    Repeat with $repeat.range

    operation

    {
      "$repeat": {
        "range": "0:-2, 10, 20:30:5",
        "value": {
          "$expression": "$repeat.value"
        }
      }
    }

    result

    [0, -1, -2, 10, 20, 25, 30]

    Repeat with $repeat.in as array

    operation

    {
      "$repeat": {
        "in": ["a", "b"],
        "value": {
          "$expression": "$repeat.value"
        }
      }
    }

    result

    ["a", "b"]

    Repeat with $repeat.in as object

    The current key is available on the scope as $repeat.key variable.

    operation

    {
      "$repeat": {
        "in": {
          "keyA": "valueA",
          "keyB": "valueB"
        },
        "value": {
          "$expression": "{key: $repeat.key, value: $repeat.value}"
        }
      }
    }

    result

    [
      { "key": "keyA", "value": "valueA" },
      { "key": "keyB", "value": "valueB" }
    ]

    Getting the current index

    The current index is available on the scope as $repeat.index variable.

    operation

    {
      "$repeat": {
        "range": "1:2",
        "value": {
          "$expression": "$repeat.index"
        }
      }
    }

    result

    [0, 1]

    Nested repeat

    Use $parent to get to the parent scope containing the parent $repeat.

    operation

    {
      "$repeat": {
        "range": "0:1",
        "value": {
          "$repeat": {
            "range": "0:1",
            "value": {
              "$expression": "$parent.$repeat.index + '.' + $repeat.index"
            }
          }
        }
      }
    }

    result

    ["0.0", "0.1", "1.0", "1.1"]

    $include

    Use $include to load other JSON or YAML files and process them in the current scope.

    javascript

    var result = jsonMerger.mergeFiles(["a.json", "b.json"]);

    a.json

    {
      "someArray": [1, 2, 3]
    }

    b.json

    {
      "someArray": [
        {
          "$include": "remove.json"
        }
      ]
    }

    remove.json

    {
      "$remove": true
    }

    result

    {
      "someArray": [2, 3]
    }

    $expression

    Use the $expression operation to calculate a value with the help of a JavaScript expression. The expression has access to the standard built-in JavaScript objects, the current scope and optionally an $input variable.

    Calculate a value

    javascript

    var result = jsonMerger.mergeFile("a.json");

    a.json

    {
      "prop": {
        "$expression": "1 + 2"
      }
    }

    result

    {
      "prop": 3
    }

    Calculate a value using $expression.input

    javascript

    var result = jsonMerger.mergeFile("b.json");

    a.json

    {
      "add": 2
    }

    b.json

    {
      "prop": {
        "$expression": {
          "expression": "1 + $input",
          "input": {
            "$import": "a.json#/add"
          }
        }
      }
    }

    result

    {
      "prop": 3
    }

    Calculate a value using the scope $targetProperty

    javascript

    var result = jsonMerger.mergeFiles(["a.json", "b.json"]);

    a.json

    {
      "prop": 1
    }

    b.json

    {
      "prop": {
        "$expression": "$targetProperty + 2"
      }
    }

    result

    {
      "prop": 3
    }

    Calculate a value using the scope $params

    javascript

    var result = jsonMerger.mergeFile("a.json", {
      params: {
        add: 2,
      },
    });

    a.json

    {
      "prop": {
        "$expression": "1 + $params.add"
      }
    }

    result

    {
      "prop": 3
    }

    Scopes

    Scopes can be created while processing operation properties. If for example a $merge.with is being processed then the merger will create a new scope for the $merge.with property. Or if a $repeat.value property is being processed a new scope is created for the $repeat.value property.

    A scope always has a $source property but not necessarily a $target property.

    When we are merging object A with object B, then the $target property in the scope of object A is undefined because object A is not merged with anything. It does have a $source property referring to object A itself. Object B on the other hand has the processed object A as $target because object B is being merged with object A. The $source property in the scope of object B refers to object B.

    If object B had defined a $merge operation, then the merger would create a new scope for the $merge.source property and a new scope for the $merge.with property.

    The $target within the $merge.source scope would be undefined because $merge.source is not merged with anything. The $target within the $merge.with scope is the processed $merge.source because $merge.with is being merged with $merge.source. The result of the $merge operation will eventually be merged with object A.

    When in the $merge.source scope it is possible to get to the root (object B) scope using the $root property or to a parent scope using the $parent property.

    interface Scope {
      $params?: any; // $params properties in current scope
      $parent?: Scope; // reference to parent scope
      $repeat?: ScopeRepeat; // $repeat properties in current scope
      $root: Scope; // reference to root scope
      $source: any; // reference to the source object
      $target?: any; // reference to the target object
    }

    Example

    javascript

    var result = jsonMerger.mergeFiles(["a.json", "b.json"]);

    a.json

    // this is the root scope
    {
      "prop1": {
        "$expression": "$target" // refers to undefined because a.json has no target
      },
      "prop2": {
        "$expression": "$targetProperty" // refers to undefined because a.json has no target
      },
      "prop3": {
        "$expression": "$source" // refers to the unprocessed a.json
      },
      "prop4": {
        "$expression": "$sourceProperty" // refers to the unprocessed a.json#/prop4
      },
      "prop5": {
        "$expression": "$root.$target" // refers to undefined because a.json has no target
      },
      "prop6": {
        "$expression": "$root.$source" // refers to the unprocessed a.json
      },
      "prop7": {
        "$expression": "$parent" // refers to undefined because the current scope has no parent scope
      },
    }

    b.json

    // this is the root scope
    {
      "prop1": {
        "$expression": "$target" // refers to the processed a.json
      },
      "prop2": {
        "$expression": "$targetProperty" // refers to the processed a.json#/prop2
      },
      "prop3": {
        "$expression": "$source" // refers to the unprocessed b.json
      },
      "prop4": {
        "$expression": "$sourceProperty" // refers to the unprocessed b.json#/prop4
      },
      "prop5": {
        "$merge": {
          "source": { // $merge.source creates a new scope
            "prop1": {
              "$expression": "$target" // refers to undefined because b.json#/prop5/$merge/source has no target
            },
            "prop2": {
              "$expression": "$targetProperty" // refers to undefined because b.json#/prop5/$merge/source has no target
            },
            "prop3": {
              "$expression": "$source" // refers to the unprocessed b.json#/prop5/$merge/source
            },
            "prop4": {
              "$expression": "$sourceProperty" // refers to the unprocessed b.json#/prop5/$merge/source/prop4
            }
            "prop5": {
              "$expression": "$root.$target" // refers to the processed a.json
            }
            "prop6": {
              "$expression": "$root.$source" // refers to the unprocessed b.json
            },
            "prop7": {
              "$expression": "$parent.$target" // refers to the processed a.json
            }
            "prop8": {
              "$expression": "$parent.$source" // refers to the unprocessed b.json
            }
          },
          "with": { // $merge.with creates a new scope
            "prop1": {
              "$expression": "$target" // refers to the processed b.json#/prop5/$merge/source
            },
            "prop2": {
              "$expression": "$targetProperty" // refers to the processed b.json#/prop5/$merge/source/prop2
            },
            "prop3": {
              "$expression": "$source" // refers to the unprocessed b.json#/prop5/$merge/with
            },
            "prop4": {
              "$expression": "$sourceProperty" // refers to the unprocessed b.json#/prop5/$merge/with/prop4
            },
            "prop5": {
              "$expression": "$root.$target" // refers to the processed a.json
            },
            "prop6": {
              "$expression": "$root.source" // refers to the unprocessed b.json
            },
            "prop7": {
              "$expression": "$parent.$target" // refers to the processed a.json
            },
            "prop8": {
              "$expression": "$parent.source" // refers to the unprocessed b.json
            }
          }
        }
      },
      "prop6": {
        "$repeat": {
          "range": "0:1",
          "value": { // $repeat.value creates a new scope with a $repeat property on it
            "$repeat": {
              "range": "0:1",
              "value": { // $repeat.value creates a new scope with a $repeat property on it
                "$expression": "'This is item ' + $parent.$repeat.index + '.' + $repeat.index"
              }
            }
          }
        }
      }
    }

    Command line interface json-merger

    You can use json-merger as a command line tool:

      Usage: json-merger [options] <file ...>
    
    
      Options:
    
        -V, --version                       output the version number
        -p, --pretty                        pretty-print the output json
        -o, --output [file]                 the output file. Defaults to stdout
        -op, --operation-prefix [prefix]    the operation prefix. Defaults to $
        -am, --default-array-merge-operation [operation]      the default array merge operation. Defaults to combine
        --error-on-file-not-found           throw an error if a file is not found. Defaults to true
        --error-on-ref-not-found            throw an error if a JSON pointer or JSON path is not found. Defaults to true
        -h, --help                          output usage information
    

    Usage:

    json-merger a.json > result.json
    json-merger --output result.json a.json
    json-merger --output result.json --pretty a.json

    Install json-merger globally to be able to use the command line interface.

    npm install -g json-merger

    Roadmap

    • Add configurable file resolvers to import files from different sources.
    • Add configurable (de)serializers to import and export different file formats.

    Install

    npm i json-merger

    DownloadsWeekly Downloads

    3,135

    Version

    1.1.5

    License

    MIT

    Unpacked Size

    170 kB

    Total Files

    103

    Last publish

    Collaborators

    • avatar