Ensuring immutability in JavaScript means creating objects and values that cannot be changed once they are created.
While JavaScript does not have built-in support for immutability in the way that some other languages do, there are several practices and libraries that you can use to achieve this goal.

Declaring variables with const ensures that the variable itself cannot be reassigned, but if the variable is an object or an array, its contents can still be changed:

const a = [1, 2, 3];
a.push(4); // This will work because the array itself is mutable.
a = [4, 5, 6]; // This will cause an error because `a` cannot be reassigned.

You can use Object.freeze() to make an object immutable.
It prevents new properties from being added to the object, existing properties from being removed, and it prevents changing the enumerability, configurability, and writability of existing properties:

const obj = { x: 5, y: 6 };
Object.freeze(obj);
obj.x = 10; // Will have no effect 

Libraries such as Immutable.js provide persistent immutable data structures. These are collections that, once created, are never changed. Any modifications to the collection return a new collection that shares as much of the structure with the original as possible, minimizing unnecessary copying.

Using functional programming practices such as avoiding side effects and using pure functions can help ensure immutability. By always returning new objects and never modifying input parameters, you can create a more predictable and maintainable codebase.

Creating deep copies of objects ensures that you're working with a completely separate copy and not a reference to the original object. Be cautious, though, as deep copying can be computationally expensive.

TypeScript can allow you to define read-only properties and provide compile-time checks for immutability:

type Point = Readonly<{
  x: number;
  y: number;
}>

ESLint can help ensure immutability in JavaScript by providing linting rules that enforce certain coding practices related to immutability.
Here are some ways ESLint can be used for this purpose.

• prefer-const: This rule flags variables that are never reassigned, signaling that they should be declared using the const keyword.
• no-var: This rule requires let or const instead of var, encouraging block scoping and potentially more predictable behavior.

There are ESLint plugins specifically designed to enforce immutability, such as eslint-plugin-immutable.
This plugin provides several rules like:

• immutable/no-mutation: This rule forbids the mutation of variables and object properties.
• immutable/no-this: This rule forbids the use of this, helping to promote functional programming patterns.

ESLint can be used in combination with tools like TypeScript, which can enforce immutability through type annotations. ESLint has good integration with TypeScript, allowing you to lint TypeScript code and enforce practices like using readonly for properties.

You can customize ESLint rules and create your own rules to enforce specific immutability patterns within your project.