@twin.org/nameof 0.0.3-next.21 → 0.0.3-next.23

package/README.md

@@ -1,8 +1,6 @@
 # TWIN Nameof
 
-The methods in this package are used to convert TypeScript class/type/property names to embedded strings, so that they are available to your JavaScript code at runtime.
-
-This package is used in conjunction with the `@twin.org/nameof-transformer` package, without using the transformer for compilation you will end up with an error string embedded in your code instead of the runtime name you are expecting.
+This package is part of the framework workspace and provides the definitions for the methods which are processed by the nameof-transformer to support consistent development workflows across the ecosystem.
 
 ## Installation
 

package/docs/changelog.md

@@ -1,4 +1,32 @@
-# @twin.org/nameof - Changelog
+# Changelog
+
+## [0.0.3-next.23](https://github.com/twinfoundation/framework/compare/nameof-v0.0.3-next.22...nameof-v0.0.3-next.23) (2026-03-17)
+
+
+### Miscellaneous Chores
+
+* **nameof:** Synchronize repo versions
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * devDependencies
+    * @twin.org/nameof-transformer bumped from 0.0.3-next.22 to 0.0.3-next.23
+
+## [0.0.3-next.22](https://github.com/twinfoundation/framework/compare/nameof-v0.0.3-next.21...nameof-v0.0.3-next.22) (2026-02-26)
+
+
+### Miscellaneous Chores
+
+* **nameof:** Synchronize repo versions
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * devDependencies
+    * @twin.org/nameof-transformer bumped from 0.0.3-next.21 to 0.0.3-next.22
 
 ## [0.0.3-next.21](https://github.com/twinfoundation/framework/compare/nameof-v0.0.3-next.20...nameof-v0.0.3-next.21) (2026-02-26)
 

package/docs/examples.md

@@ -1,74 +1,60 @@
-# @twin.org/nameof - Examples
+# Nameof Examples
 
-## `nameof<T>`
+Use these snippets for strongly typed name extraction patterns that remain safe during refactors.
 
-One of the internal transformers in the TypeScript compiler will reduce an interface to no code, which means that at runtime the type information is missing. So operations where you might like to find the name of a class/type etc are not available.
-
-We have many places in our code where we want to use the name of the class, we could do the following.
+## `nameof`
 
 ```typescript
-export class MyClass {
-  public static className(): string {
-    return 'MyClass';
-  }
-}
-console.log(MyClass.className()); // Outputs "MyClass"
-```
+import { nameof } from '@twin.org/nameof';
 
-But if you changed the name of the class you would have to make sure you also replaced all string instances where it was mentioned as well, this is prone to lots of errors.
+class AccountState {
+  public id!: string;
+}
 
-We can use the `nameof` transformer as follows.
+nameof<AccountState>(); // 'AccountState'
+```
 
 ```typescript
 import { nameof } from '@twin.org/nameof';
 
-export class MyClass {
-  public static className(): string {
-    return nameof<MyClass>();
-  }
+interface Profile {
+  displayName: string;
+  stats?: {
+    loginCount: number;
+  };
 }
-console.log(MyClass.className()); // Outputs "MyClass"
-```
-
-Now if we rename `MyClass` without updating the references in the `nameof` call we will get a compiler error, code auto refactoring would actually perform the rename for us.
 
-Since `nameof` is performed as a compile time transform, the actual code produced looks like this.
+const profile: Profile = {
+  displayName: 'Ari',
+  stats: {
+    loginCount: 12
+  }
+};
 
-```javascript
-export class MyClass {
-    static public className(): string {
-        return "MyClass";
-    }
-}
-console.log(MyClass.className()); // Outputs "MyClass"
+nameof(profile.displayName); // 'displayName'
+nameof(profile.stats?.loginCount); // 'stats.loginCount'
 ```
 
-This means there is no additional overheads in function calls at runtime.
-
-## `nameof(propName)`
-
-The `nameof(propName)` transform behaves in much the same way as `nameof<T>`, but instead works on properties passed to it.
+## `nameofKebabCase`
 
 ```typescript
-import { nameof } from '@twin.org/nameof';
+import { nameofKebabCase } from '@twin.org/nameof';
 
-export class MyClass {
-  public static propName(aProp: string): string {
-    return nameof(aProp);
-  }
+class ReportSummary {
+  public totalCount!: number;
 }
-console.log(MyClass.propName()); // Outputs "aProp"
+
+nameofKebabCase<ReportSummary>(); // 'report-summary'
 ```
 
-You can also used it with chained properties, nullish operators can also be used, but are removed.
+## `nameofCamelCase`
 
 ```typescript
-import { nameof } from '@twin.org/nameof';
+import { nameofCamelCase } from '@twin.org/nameof';
 
-export class MyClass {
-  public static propName(aProp: { inner?: boolean }): string {
-    return nameof(aProp?.inner);
-  }
+class UserProfileRecord {
+  public profileImageUrl!: string;
 }
-console.log(MyClass.propName()); // Outputs "aProp.inner"
+
+nameofCamelCase<UserProfileRecord>(); // 'userProfileRecord'
 ```

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@twin.org/nameof",
-	"version": "0.0.3-next.21",
-	"description": "Provides the definitions for the methods which are processed by the nameof-transformer",
+	"version": "0.0.3-next.23",
+	"description": "The definitions for the methods which are processed by the nameof-transformer",
 	"repository": {
 		"type": "git",
 		"url": "git+https://github.com/twinfoundation/framework.git",