remutable-ts 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Dan Funder Christoffersen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,100 @@
+# remutable-ts
+
+remutable-ts provides a simple and **type-safe** way to remove readonly
+modifiers from types in TypeScript.
+
+This is useful when you:
+
+- Need to **mutate objects** that are defined as **readonly** (e.g. libraries,
+  framework types).
+- Prefer solutions with **no runtime** overhead.
+
+### ⚡ Why not just remove readonly?
+
+Keeping `readonly` by default is safer as it prevents unintended mutations.
+`remutable-ts` allows controlled mutation, even in external modules where
+needed, giving you flexibility without sacrificing type safety.
+
+## Installation
+
+For **usage as a devDependency with zero runtime**:
+
+```bash
+npm install --save-dev remutable-ts
+```
+
+## Usage
+
+### 1. Make any type mutable
+
+```typescript
+type Example = {
+	readonly a: number;
+	readonly b: string;
+	readonly nested: {
+		readonly c: boolean; // Note nested properties will remain readonly
+	};
+};
+
+const example: Example = {
+	a: 1,
+	b: "hello",
+	nested: {
+		c: true
+	},
+};
+
+// Inline example usage
+(example as Mutable<Example>).a = 2; ✅ allowed now
+
+// Using Mutable<T> to get a fully writable type
+const writableExample = example as Mutable<Example>;
+
+writableExample.a = 2; ✅ allowed now
+writableExample.b = "world"; ✅ allowed now
+// writableExample.nested.c = false; // Error: Cannot assign to 'c' because it remains a read-only property.
+
+console.log("Original example:", example);
+console.log("Writable example before mutation:", writableExample);
+```
+
+### 2. Using mutable(this) inside a class to get a writable view
+
+```typescript
+// 
+class MyClass {
+	readonly x: number = 5; // Always apply type to literal values
+	readonly name: string = "Alice"; // Always apply type to literal values
+
+	update() {
+		(this as Mutable<this>).x = 20;  ✅ allowed now
+
+		// or using mutable helper function
+		mutable(this).name = "Bob";  ✅ allowed now
+	}
+}
+
+const myInstance = new MyClass();
+console.log("Before update:", myInstance);
+myInstance.update();
+console.log("After update:", myInstance);
+```
+
+#### ⚠️ Gotcha: literal types
+
+When you initialize a readonly property with a literal value (e.g.,
+`readonly score = 0`), TypeScript infers a literal type (`0`), not the broader
+type (`number`). This can cause assignment errors when using `Mutable<T>` or
+`mutable<T>()`, since you can't assign, say, `1` to a property of type `0`.
+
+**Recommendation:** Explicitly type such properties to avoid this issue:
+
+```typescript
+const score: Mutable<{ readonly score: number }> = { score: 0 }; // ✅ Use an explicit type
+```
+
+This ensures `Mutable<T>` and `mutable<T>()` work as expected for assignments.
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * A utility type that removes readonly modifiers from all properties of T,
+ * keeping the type structure intact with no runtime impact.
+ */
+export type Mutable<T> = {
+    -readonly [K in keyof T]: T[K];
+};
+/**
+ * Returns the given object typed as Mutable<T>, effectively removing readonly
+ * modifiers from its properties. This function preserves the original type shape and only has i minimal runtime impact.
+ */
+export declare function mutable<T>(obj: T): Mutable<T>;

package/dist/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mutable = mutable;
+/**
+ * Returns the given object typed as Mutable<T>, effectively removing readonly
+ * modifiers from its properties. This function preserves the original type shape and only has i minimal runtime impact.
+ */
+function mutable(obj) {
+    return obj;
+}

package/package.json

@@ -0,0 +1,31 @@
+{
+	"name": "remutable-ts",
+	"version": "0.0.1",
+	"description": "TypeScript utility to safely bypass readonly at compile-time with zero runtime overhead.",
+	"main": "dist/index.js",
+	"types": "dist/index.d.ts",
+	"files": [
+		"dist"
+	],
+	"scripts": {
+		"build": "tsc",
+		"example": "npx ts-node example/index.ts"
+	},
+	"keywords": [
+		"typescript",
+		"utility",
+		"types",
+		"readonly",
+		"mutable"
+	],
+	"author": "FunderForge",
+	"license": "MIT",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/Funder75/remutable-ts"
+	},
+	"devDependencies": {
+		"@types/node": "^20.11.24",
+		"typescript": "^5.3.3"
+	}
+}