@contractkit/plugin-csharp 0.0.0

package/dist/naming.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Identifier and file-name conversions for C# output.
+ *
+ * Kept separate from the codegen modules because both the model and the client generators need the
+ * same conversions, and a mismatch between them would produce a client that references a property
+ * name the model never declared.
+ */
+/**
+ * C#'s reserved keywords — illegal as bare identifiers anywhere, so a name that collides with one
+ * has to be escaped with `@`. Contextual keywords (`record`, `required`, `init`, `value`, `var`,
+ * `async`, `await`, `yield`, `nameof`, `when`) are legal identifiers and are deliberately absent:
+ * escaping them would only make the generated code noisier.
+ */
+export declare const CSHARP_KEYWORDS: ReadonlySet<string>;
+/**
+ * Prefix `name` with `@` when it is a C# keyword, so it can still be used as a parameter or local.
+ * The `@` is a lexical escape only: the identifier is still spelled `name` everywhere it matters,
+ * including in `nameof` and in reflection, so nothing downstream has to know about it.
+ */
+export declare function escapeCSharpIdentifier(name: string): string;
+/**
+ * Convert a contract field name to a C# property name in PascalCase.
+ *
+ * Separators (`-`, `_`, `.`, spaces) introduce a word boundary and are dropped, so `x-request-id`
+ * becomes `XRequestId`. A leading digit gets an underscore prefix, since C# identifiers cannot
+ * start with one. No keyword escaping is needed: every C# keyword is lowercase and this always
+ * produces an initial capital.
+ *
+ * The original name is preserved on the wire through `[JsonPropertyName]`, so this conversion is
+ * free to be lossy as long as it is deterministic.
+ */
+export declare function toCSharpPropertyName(name: string): string;
+/**
+ * Convert a contract parameter or path placeholder to a C# parameter name in camelCase:
+ * `invoice-id` becomes `invoiceId`. Keyword-escaped, because camelCase lands on keywords
+ * regularly — a path parameter named `event` or `params` is ordinary in a contract.
+ */
+export declare function toCSharpParameterName(name: string): string;
+/**
+ * Make a property name safe inside `ownerTypeName`.
+ *
+ * C# rejects a member whose name matches its enclosing type (CS0542), which a contract hits
+ * whenever a model has a field of its own name — `contract Invoice { invoice: ... }`. A record also
+ * synthesizes members that a contract field can collide with. Both are resolved by appending
+ * `Value`; the wire name is unaffected, since `[JsonPropertyName]` is always emitted.
+ */
+export declare function safeMemberName(propertyName: string, ownerTypeName: string): string;
+/**
+ * Convert a name to a C# type name in PascalCase. Never escaped: type names are generated (from
+ * model names, method names, or status codes) rather than taken verbatim, so a collision with a
+ * keyword is a naming bug worth surfacing rather than papering over.
+ */
+export declare function toCSharpTypeName(name: string): string;
+/**
+ * Make an already-composed name safe to use as a C# type name, without re-casing it.
+ *
+ * Distinct from {@link toCSharpTypeName}, which splits a source name into words and rebuilds it:
+ * running that over a name already assembled from PascalCase parts would fold `MV` back to `Mv`.
+ */
+export declare function sanitizeCSharpTypeName(name: string): string;
+/**
+ * Convert an enum member value to a C# enum member name in PascalCase: `in-progress` becomes
+ * `InProgress`. The value itself always travels via `[JsonStringEnumMemberName]`, so this only has
+ * to be a stable identifier.
+ */
+export declare function toCSharpEnumMemberName(value: string): string;
+/**
+ * Derive the PascalCase base used for a generated file's names from a `.ck` file path:
+ * `"ledger.categories.ck"` becomes `"LedgerCategories"`. Both the models file and the client class
+ * for one source file are named from this, so they stay visibly paired in the output tree.
+ */
+export declare function deriveCSharpFileBase(file: string): string;
+/**
+ * Render `text` as an XML doc comment indented by `indent`, wrapped in `tag`. Returns `[]` for
+ * empty text so callers can splat unconditionally.
+ *
+ * `///` is a line comment, so unlike Kotlin's KDoc there is no delimiter to break out of. What does
+ * have to be handled is XML: an unescaped `&` or `<` in a description makes the doc file malformed,
+ * which the compiler reports as a warning and `-warnaserror` turns into a build failure.
+ */
+export declare function xmlDocLines(text: string, indent: string, tag?: string): string[];
+/** Escape the three characters that would otherwise make a doc comment malformed XML. */
+export declare function escapeXml(text: string): string;
+/**
+ * Render `value` as a C# string literal. No `$` handling: interpolated strings are the only place
+ * `$` is special, and no generated literal built from contract text is interpolated.
+ */
+export declare function quoteCSharpString(value: string): string;
+//# sourceMappingURL=naming.d.ts.map

package/dist/naming.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"naming.d.ts","sourceRoot":"","sources":["../src/naming.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;;;;GAKG;AACH,eAAO,MAAM,eAAe,EAAE,WAAW,CAAC,MAAM,CA8E9C,CAAC;AAQH;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE3D;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAMzD;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAQ1D;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,YAAY,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,MAAM,CAGlF;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAMrD;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAM3D;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAM5D;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAOzD;AAED;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,SAAY,GAAG,MAAM,EAAE,CAMnF;AAED,yFAAyF;AACzF,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE9C;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CASvD"}

package/dist/runtime-converters.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The `Runtime/Converters.cs` file: the shared `JsonSerializerOptions` and the converters for the
+ * three ContractKit scalars whose BCL type does not serialize the way the contract says it travels.
+ *
+ * These live in the generated output rather than in a published NuGet package so the SDK has no
+ * dependency at all. The same choice the Python plugin makes with `_base_client.py` and the Kotlin
+ * plugin with `Serializers.kt`.
+ *
+ * Enums, unions and tuples are not handled here: each carries a `[JsonConverter]` attribute of its
+ * own, so it serializes correctly under any options. These three are options-level, which is why
+ * anything serializing a generated model by hand has to pass `SdkJson.Options`.
+ */
+/** Generate `Runtime/Converters.cs` for `namespaceName`. Content depends on nothing but the namespace. */
+export declare function generateConvertersCs(namespaceName: string): string;
+//# sourceMappingURL=runtime-converters.d.ts.map

package/dist/runtime-converters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-converters.d.ts","sourceRoot":"","sources":["../src/runtime-converters.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,0GAA0G;AAC1G,wBAAgB,oBAAoB,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM,CAoIlE"}

package/dist/runtime.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The `Runtime/SdkRuntime.cs` file: the `HttpClient` wrapper every generated client is built on.
+ *
+ * Nothing here comes from outside the BCL, so a generated SDK restores and builds with no NuGet
+ * feed at all. The TypeScript, Python and Kotlin SDKs likewise read and write their own bodies
+ * rather than delegating to a content-negotiation layer.
+ */
+/** Generate `Runtime/SdkRuntime.cs` for `namespaceName`. Content depends on nothing but the namespace. */
+export declare function generateRuntimeCs(namespaceName: string): string;
+//# sourceMappingURL=runtime.d.ts.map

package/dist/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../src/runtime.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,0GAA0G;AAC1G,wBAAgB,iBAAiB,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM,CAmX/D"}

package/dist/scaffold.d.ts

@@ -0,0 +1,26 @@
+/**
+ * The project file a generated SDK needs to build on its own.
+ *
+ * Emitted with `ifAbsent`, so it is created once and then belongs to the user: a project will add a
+ * package id, a version, an analyzer set and a signing key of its own, and regenerating over that
+ * would throw the work away. Generated C# sources are rewritten every run; this is not.
+ */
+/**
+ * What the scaffold pins. One object so a bump is one edit.
+ *
+ * There is deliberately no dependency list to go with it: the generated SDK uses only
+ * `System.Text.Json` and `HttpClient` from the shared framework, so `dotnet build` restores with no
+ * NuGet feed reachable at all.
+ */
+export declare const SCAFFOLD_VERSIONS: {
+    readonly targetFramework: "net10.0";
+};
+/**
+ * Generate `<SdkName>.csproj`.
+ *
+ * `ImplicitUsings` is off because generated files carry an explicit `using` block of their own, and
+ * leaving it on would make the output depend on the SDK's implicit set rather than on what the
+ * generator wrote.
+ */
+export declare function generateCsproj(namespaceName: string, sdkName: string): string;
+//# sourceMappingURL=scaffold.d.ts.map

package/dist/scaffold.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scaffold.d.ts","sourceRoot":"","sources":["../src/scaffold.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB;;CAEpB,CAAC;AAEX;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,aAAa,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAc7E"}

package/eslint.config.js

@@ -0,0 +1,6 @@
+//  @ts-check
+
+import base from '@repo/config-eslint/base.js';
+
+/** @type {import("eslint").Linter.Config[]} */
+export default [...base];

package/package.json

@@ -0,0 +1,48 @@
+{
+    "name": "@contractkit/plugin-csharp",
+    "version": "0.0.0",
+    "description": "ContractKit built-in plugin: C#/.NET SDK client generation (System.Text.Json + HttpClient, no NuGet dependencies)",
+    "license": "MIT",
+    "author": {
+        "name": "Marooned Software",
+        "url": "https://github.com/MaroonedSoftware/contractkit"
+    },
+    "bugs": {
+        "url": "https://github.com/MaroonedSoftware/contractkit/issues"
+    },
+    "homepage": "https://github.com/MaroonedSoftware/contractkit/packages/plugin-csharp#readme",
+    "keywords": [
+        "contractkit",
+        "csharp",
+        "dotnet",
+        "system.text.json"
+    ],
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/MaroonedSoftware/contractkit.git"
+    },
+    "type": "module",
+    "main": "./dist/index.js",
+    "module": "./dist/index.js",
+    "types": "./dist/index.d.ts",
+    "exports": {
+        ".": "./dist/index.js"
+    },
+    "scripts": {
+        "build": "tsup src/index.ts --format esm --sourcemap --dts && tsc --emitDeclarationOnly --declaration",
+        "build:ci": "eslint --max-warnings=0 && pnpm run build",
+        "lint": "eslint --fix",
+        "format": "prettier --write .",
+        "test": "vitest run",
+        "test:ci": "vitest run --coverage"
+    },
+    "dependencies": {
+        "@contractkit/core": "workspace:*"
+    },
+    "devDependencies": {
+        "@repo/config-eslint": "workspace:*",
+        "@repo/config-typescript": "workspace:*",
+        "unplugin-swc": "^1.5.9",
+        "vitest": "^4.1.5"
+    }
+}