ts-clone-node

> A library that helps you clone Nodes from a Typescript AST

Description

The Typescript Compiler API is very powerful and comes with a lot of create and update functions that can be used for creating and updating nodes in Custom transformers while visiting
a SourceFile. Under such circumstances, it is easy to run into problems if you reuse a Node in another part of the tree without properly cloning it, since the parent chain, as well as the pos and end values will have wrong values and will lead to malformed output after your transformations have been applied.

This can be cumbersome for example when you want to simply add or remove a specific modifier from an arbitrary node in a given position.
This library exports a cloneNode function that makes it easy to deep-clone a Node from a Typescript AST without any faulty parent links.
Additionally, you get a simple hook with which you can do simple things such as edit the top-level properties of the cloned object such as its modifiers, decorators, etc.

$3

- Simple to use
- Extensible
- Supports dynamic TypeScript versions

Backers

$3

Table of Contents

- Description
- Features
- Backers
- Patreon
- Table of Contents
- Install
- npm
- Yarn
- pnpm
- Peer Dependencies
- Usage
- Configuration
- Hooking into and altering transformations
- Passing in a specific TypeScript version
- Passing in a specific NodeFactory
- Setting parent pointers
- Setting original node pointers
- Preserving comments
- Preserving symbols
- Contributing
- Maintainers
- FAQ
- What is the point of this library
- License

Install

$3

``
$ npm install ts-clone-node
`

$3

`
$ yarn add ts-clone-node
`

$3

`
$ pnpm add ts-clone-node
`

$3

ts-clone-node depends on typescript, so you need to manually install this as well.

Usage

To clone a Node from a Typescript AST, all you have to do is:

`typescript
import {cloneNode} from "ts-clone-node";

// Clone the Node
const clonedNode = cloneNode(someNode);
`

Configuration

$3

You can pass in a hook that enables you to modify the clone, agnostic to the kind of Node it is.
For example:

`typescript
import {cloneNode} from "ts-clone-node";

// Clone the Node, and alter the modifiers such that they don't include a modifier pointing
// to the 'declare' keyword
const clonedNode = cloneNode(someNode, {
hook: node => {
return {
modifiers: modifiers => ensureNoDeclareModifier(modifiers)
};
}
});
`

There is also a _'finalize'_ which is invoked after a node has been cloned at any recursive step from the top node, allowing you to perform
final alterations or track the node for other purposes.

`typescript
const clonedNode = cloneNode(someNode, {
finalize: (clonedNode, oldNode) => trackSomething(clonedNode, oldNode)
});
`

$3

You can use pass a specific TypeScript to use as an option to cloneNode:

`typescript
cloneNode(someNode, {
typescript: specialTypescriptVersion
});
`

This can be useful, for example, in an environment where multiple packages in the same project depends
on different TypeScript versions and you're relying on cloneNode.

$3

From TypeScript v4 and forward, a NodeFactory can be retrieved from a TransformationContext to signal which transformer was responsible for creating or altering nodes. If you want to pass a specific NodeFactory, you can pass it as an option to cloneNode:

`typescript
cloneNode(someNode, {
factory: nodeFactoryFromTransformationContext
});
`

$3

By default, when you clone a node, it won't update the parent pointers such that you and TypeScripts compiler APIs can traverse the parent tree.
You can toggle this behavior with the setParents option:

`typescript
cloneNode(someNode, {
setParents: true
});
`

$3

By default, when you clone a node, it won't keep references to the original nodes recursively.
You can toggle this behavior with the setOriginalNodes option:

`typescript
cloneNode(someNode, {
setOriginalNodes: true
});
`

$3

By default, when you clone a node, comments will be preserved as much as possible and added to the cloned nodes as emitNodes.
You can toggle this behavior with the preserveComments option:

`typescript
cloneNode(someNode, {
preserveComments: false
});
`

$3

By default, when you clone a node, it won't preserve symbols from the original nodes.
You can toggle this behavior with the preserveSymbols option:

`typescript
cloneNode(someNode, {
preserveSymbols: true
});
``

Contributing

Do you want to contribute? Awesome! Please follow these recommendations.

Maintainers

| |
| -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Frederik Wessberg
Twitter: @FredWessberg
Github: @wessberg
_Lead Developer_ |

FAQ

$3

If you've run into the kind of trouble I'm explaining here, you'll understand. If not, I'm happy for you. You can move along!

License

MIT © Frederik Wessberg (@FredWessberg) (Website)