@contractkit/plugin-csharp 0.0.0

package/src/index.ts

@@ -0,0 +1,373 @@
+import { dirname, join, resolve } from 'node:path';
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, rmdirSync, writeFileSync } from 'node:fs';
+import type {
+    ContractKitPlugin,
+    ContractRootNode,
+    ContractTypeNode,
+    IncrementalManifest,
+    IncrementalOutputFile,
+    IncrementalUnit,
+    ModelNode,
+    OpRootNode,
+    ParamSource,
+    PluginContext,
+} from '@contractkit/core';
+import {
+    buildModelIndex,
+    collectTransitiveModelRefs,
+    collectTypeRefs,
+    emptyIncrementalManifest,
+    hashFingerprint,
+    parseIncrementalManifest,
+    runIncrementalCodegen,
+    serializeIncrementalManifest,
+} from '@contractkit/core';
+import { generateCSharpModels, resolveModelsWithInput } from './codegen-models.js';
+import { deriveClientClassName, deriveClientPropertyName, generateCSharpClient, hasPublicOperations } from './codegen-client.js';
+import { generateSdkCs, type SdkAggregatorClient } from './codegen-sdk.js';
+import { collectHoistedTypes } from './hoist.js';
+import { generateRuntimeCs } from './runtime.js';
+import { generateConvertersCs } from './runtime-converters.js';
+import { generateCsproj } from './scaffold.js';
+import { CSHARP_KEYWORDS, deriveCSharpFileBase } from './naming.js';
+
+export interface CSharpSdkPluginConfig {
+    /** Output directory relative to rootDir (default: "csharp-sdk") */
+    baseDir?: string;
+    /** Root namespace for the generated sources, e.g. "Acme.Sdk" (default: "ContractKit.Sdk") */
+    namespace?: string;
+    /** Aggregator class name (default: "Sdk"). Also the assembly name when scaffolding. */
+    sdkName?: string;
+    /**
+     * Whether to emit client methods for operations marked `internal`. Defaults to `false` —
+     * internal ops are omitted so consumers don't pick them up.
+     */
+    includeInternal?: boolean;
+    /** Emit `<SdkName>.csproj` once, as a user-owned file. Never overwritten. */
+    scaffold?: boolean;
+}
+
+/**
+ * Bumped when the C# codegen output shape changes in a way that should invalidate every per-file
+ * fingerprint, so a plugin upgrade forces full regeneration even when no `.ck` file has changed.
+ */
+export const CSHARP_CODEGEN_VERSION = '1';
+
+const CACHE_MANIFEST_FILENAME = 'csharp-manifest.json';
+const DEFAULT_BASE_DIR = 'csharp-sdk';
+const DEFAULT_NAMESPACE = 'ContractKit.Sdk';
+const DEFAULT_SDK_NAME = 'Sdk';
+
+const plugin: ContractKitPlugin = {
+    name: 'csharp-sdk',
+    async generateTargets(inputs, ctx) {
+        const config = ctx.options as CSharpSdkPluginConfig;
+        await runCSharpCodegen(inputs, ctx, config, ctx.rootDir);
+    },
+};
+
+export default plugin;
+
+export function createCSharpSdkPlugin(config: CSharpSdkPluginConfig, rootDir: string): ContractKitPlugin {
+    return {
+        name: 'csharp-sdk',
+        async generateTargets(inputs, ctx) {
+            await runCSharpCodegen(inputs, ctx, config, rootDir);
+        },
+    };
+}
+
+const NAMESPACE_RE = /^[A-Za-z_][A-Za-z0-9_]*(\.[A-Za-z_][A-Za-z0-9_]*)*$/;
+const SDK_NAME_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
+
+/**
+ * Reject config that would generate C# which cannot compile. These are runtime checks, not just
+ * types: config arrives as JSON, so the TypeScript interface constrains programmatic callers only.
+ */
+export function assertValidConfig(config: CSharpSdkPluginConfig): void {
+    const { namespace, sdkName } = config;
+    if (namespace !== undefined) {
+        if (typeof namespace !== 'string' || !NAMESPACE_RE.test(namespace)) {
+            throw new Error(
+                `plugin-csharp: namespace '${String(namespace)}' is not a valid C# namespace — expected dot-separated identifiers, e.g. 'Acme.Sdk'.`,
+            );
+        }
+        const keyword = namespace.split('.').find(segment => CSHARP_KEYWORDS.has(segment));
+        if (keyword) {
+            throw new Error(`plugin-csharp: namespace '${namespace}' contains the C# keyword '${keyword}', which cannot appear in a namespace.`);
+        }
+    }
+    if (sdkName !== undefined) {
+        if (typeof sdkName !== 'string' || !SDK_NAME_RE.test(sdkName)) {
+            throw new Error(`plugin-csharp: sdkName '${String(sdkName)}' is not a valid C# class name.`);
+        }
+        if (CSHARP_KEYWORDS.has(sdkName)) {
+            throw new Error(`plugin-csharp: sdkName '${sdkName}' is a C# keyword.`);
+        }
+    }
+    for (const key of ['includeInternal', 'scaffold'] as const) {
+        const value = config[key];
+        if (value !== undefined && typeof value !== 'boolean') {
+            throw new Error(`plugin-csharp: ${key} must be a boolean — got ${JSON.stringify(value)}.`);
+        }
+    }
+}
+
+/**
+ * Shared orchestration. Builds per-file fingerprints, reuses unchanged outputs from the manifest,
+ * regenerates only the affected files, and rewrites the shared runtime and aggregator every run
+ * (they are cheap and depend only on the set of public clients).
+ *
+ * Honors `ctx.cacheEnabled`, so `--force` bypasses the per-file cache.
+ */
+async function runCSharpCodegen(
+    inputs: Parameters<NonNullable<ContractKitPlugin['generateTargets']>>[0],
+    ctx: PluginContext,
+    config: CSharpSdkPluginConfig,
+    rootDir: string,
+): Promise<void> {
+    assertValidConfig(config);
+
+    const { contractRoots } = inputs;
+    const namespaceName = config.namespace ?? DEFAULT_NAMESPACE;
+    const sdkName = config.sdkName ?? DEFAULT_SDK_NAME;
+    const outDir = resolve(rootDir, config.baseDir ?? DEFAULT_BASE_DIR);
+    const manifestPath = resolve(ctx.cacheDir, CACHE_MANIFEST_FILENAME);
+
+    // Every model shares one C# namespace, so a cross-file reference resolves by name and the only
+    // cross-file input a models unit has is which names carry an Input variant.
+    const allModels: ModelNode[] = contractRoots.flatMap(root => root.models);
+    const modelIndex = buildModelIndex(allModels);
+    // Resolved once over every model, so the hoisting pass and each file's renderer agree on which
+    // names carry an `Input` variant.
+    const modelsWithInput = resolveModelsWithInput(allModels, inputs.modelsWithInput);
+    const modelsWithInputArray = [...modelsWithInput].sort();
+
+    // Names for the anonymous shapes — unions, inline objects, field-level enums, tuples — that C#
+    // needs a declaration for. Computed across every file at once: a discriminated union declared in
+    // one file makes member records generated in other files implement its interface.
+    const hoisted = collectHoistedTypes(contractRoots, {
+        modelIndex,
+        modelsWithInput,
+        warn: (message, file) => ctx.warn?.(message, file),
+    });
+
+    const prevManifest: IncrementalManifest = ctx.cacheEnabled ? readManifest(manifestPath) : emptyIncrementalManifest(CSHARP_CODEGEN_VERSION);
+    const units: IncrementalUnit[] = [];
+    const clients: SdkAggregatorClient[] = [];
+
+    for (const root of contractRoots) {
+        const relPath = `Models/${deriveCSharpFileBase(root.file)}.cs`;
+        const ownNames = new Set(root.models.map(m => m.name));
+        const referenced = referencedModelNames(root);
+        const relevantInputModels = modelsWithInputArray.filter(name => ownNames.has(name) || referenced.has(name));
+        // A base declared in another file contributes its fields to a record generated here, so the
+        // fingerprint has to move when that base does.
+        const externalBases = [...referenced]
+            .filter(name => !ownNames.has(name))
+            .sort()
+            .map(name => modelIndex.get(name))
+            .filter((m): m is ModelNode => m !== undefined);
+
+        // Declarations this file owns, and the interfaces its records implement, are both decided by
+        // the whole project, so they belong in the fingerprint alongside the file.
+        const ownedDeclarations = (hoisted.byFile.get(root.file) ?? []).map(d => ({ kind: d.kind, name: d.name, needsInput: d.needsInput }));
+        const declaredMemberships = [...ownNames]
+            .sort()
+            .map(name => [name, hoisted.memberships.get(name) ?? []] as const)
+            .filter(([, unions]) => unions.length > 0);
+
+        const fingerprint = hashFingerprint({
+            kind: 'models',
+            v: CSHARP_CODEGEN_VERSION,
+            relPath,
+            namespace: namespaceName,
+            root,
+            externalBases,
+            modelsWithInput: relevantInputModels,
+            ownedDeclarations,
+            declaredMemberships,
+        });
+
+        units.push({
+            key: `models::${relPath}`,
+            fingerprint,
+            render: () => [
+                {
+                    relativePath: relPath,
+                    content: generateCSharpModels(root, {
+                        namespace: namespaceName,
+                        modelsWithInput,
+                        modelIndex,
+                        hoisted,
+                        warn: message => ctx.warn?.(message, root.file),
+                    }),
+                },
+            ],
+        });
+    }
+
+    // ── Per-op-root client files ─────────────────────────────────────────────
+    for (const root of inputs.opRoots) {
+        if (!hasPublicOperations(root, config.includeInternal)) continue;
+        const relPath = `Clients/${deriveClientClassName(root.file)}.cs`;
+        clients.push({ className: deriveClientClassName(root.file), propertyName: deriveClientPropertyName(root.file) });
+
+        const referenced = referencedOpModels(root, modelIndex);
+        const relevantInputModels = modelsWithInputArray.filter(name => referenced.has(name));
+        // A client names the models it takes and returns, so the shapes behind those names — and
+        // the declarations hoisted out of them — are part of what this file depends on.
+        const referencedModels = [...referenced]
+            .sort()
+            .map(name => modelIndex.get(name))
+            .filter((m): m is ModelNode => m !== undefined);
+
+        const fingerprint = hashFingerprint({
+            kind: 'client',
+            v: CSHARP_CODEGEN_VERSION,
+            relPath,
+            namespace: namespaceName,
+            root,
+            referencedModels,
+            modelsWithInput: relevantInputModels,
+            includeInternal: config.includeInternal ?? false,
+        });
+
+        units.push({
+            key: `client::${relPath}`,
+            fingerprint,
+            render: () => [
+                {
+                    relativePath: relPath,
+                    content: generateCSharpClient(root, {
+                        namespace: namespaceName,
+                        modelsWithInput,
+                        modelIndex,
+                        hoisted,
+                        includeInternal: config.includeInternal,
+                        warn: message => ctx.warn?.(message, root.file),
+                    }),
+                },
+            ],
+        });
+    }
+
+    // The runtime is a constant, and the aggregator depends only on the list of public clients.
+    // Both are small enough that rewriting them every run beats a cache entry.
+    const globalFiles: IncrementalOutputFile[] = [
+        { relativePath: 'Runtime/Converters.cs', content: generateConvertersCs(namespaceName) },
+        { relativePath: 'Runtime/SdkRuntime.cs', content: generateRuntimeCs(namespaceName) },
+        { relativePath: `${sdkName}.cs`, content: generateSdkCs(namespaceName, sdkName, clients) },
+    ];
+
+    // `ifAbsent` marks this user-owned: written once, never overwritten, and never removed as an
+    // orphan when the generated tree changes around it.
+    if (config.scaffold) {
+        globalFiles.push({ relativePath: `${sdkName}.csproj`, content: generateCsproj(namespaceName, sdkName), ifAbsent: true });
+    }
+
+    const result = runIncrementalCodegen({
+        codegenVersion: CSHARP_CODEGEN_VERSION,
+        prevManifest,
+        globalFiles,
+        units,
+        fileExists: relPath => existsSync(resolve(outDir, relPath)),
+    });
+
+    deleteStalePaths(outDir, result.deletedPaths);
+
+    for (const { relativePath, content, ifAbsent } of result.filesToWrite) {
+        ctx.emitFile(resolve(outDir, relativePath), content, ifAbsent ? { ifAbsent: true } : undefined);
+    }
+
+    writeManifest(manifestPath, result.manifest);
+}
+
+/** Every model name an operations file names, transitively, so the client's inputs are covered. */
+function referencedOpModels(root: OpRootNode, modelIndex: Map<string, ModelNode>): Set<string> {
+    const seeds: ContractTypeNode[] = [];
+    const addParamSource = (source: ParamSource | undefined): void => {
+        if (!source) return;
+        if (source.kind === 'params') seeds.push(...source.nodes.map(n => n.type));
+        else if (source.kind === 'ref') seeds.push({ kind: 'ref', name: source.name });
+        else seeds.push(source.node);
+    };
+
+    for (const route of root.routes) {
+        addParamSource(route.params);
+        for (const op of route.operations) {
+            addParamSource(op.query);
+            addParamSource(op.headers);
+            for (const body of op.request?.bodies ?? []) seeds.push(body.bodyType);
+            for (const response of op.responses) {
+                for (const body of response.bodies) seeds.push(body.bodyType);
+                for (const header of response.headers ?? []) seeds.push(header.type);
+            }
+        }
+    }
+
+    return collectTransitiveModelRefs(seeds, modelIndex);
+}
+
+/** Every model name a contract root references but may not define, including its bases. */
+function referencedModelNames(root: ContractRootNode): Set<string> {
+    const refs = new Set<string>();
+    for (const model of root.models) {
+        if (model.type) collectTypeRefs(model.type, refs);
+        for (const f of model.fields) collectTypeRefs(f.type, refs);
+        if (model.bases) for (const base of model.bases) refs.add(base);
+    }
+    return refs;
+}
+
+/** Read the previous run's manifest. Returns an empty manifest when missing or unreadable. */
+function readManifest(manifestPath: string): IncrementalManifest {
+    if (!existsSync(manifestPath)) return emptyIncrementalManifest(CSHARP_CODEGEN_VERSION);
+    try {
+        return parseIncrementalManifest(readFileSync(manifestPath, 'utf-8'));
+    } catch {
+        return emptyIncrementalManifest(CSHARP_CODEGEN_VERSION);
+    }
+}
+
+/** Write the manifest. Errors are swallowed so a broken cache never blocks the build. */
+function writeManifest(manifestPath: string, manifest: IncrementalManifest): void {
+    try {
+        mkdirSync(dirname(manifestPath), { recursive: true });
+        writeFileSync(manifestPath, serializeIncrementalManifest(manifest), 'utf-8');
+    } catch {
+        // best-effort
+    }
+}
+
+/**
+ * Delete paths from the prior manifest that aren't produced this run, then prune the directories
+ * they leave empty. The output tree is nested (`Models/`, `Clients/`, `Runtime/`), so a renamed
+ * `.ck` file would otherwise leave an empty directory behind.
+ */
+function deleteStalePaths(outDir: string, relPaths: string[]): void {
+    if (relPaths.length === 0) return;
+    const removedDirs = new Set<string>();
+    for (const rel of relPaths) {
+        const abs = resolve(outDir, rel);
+        if (existsSync(abs)) {
+            rmSync(abs, { force: true });
+            removedDirs.add(join(abs, '..'));
+        }
+    }
+    for (const dir of removedDirs) {
+        let current = dir;
+        while (current.startsWith(outDir) && current !== outDir) {
+            try {
+                if (readdirSync(current).length === 0) {
+                    rmdirSync(current);
+                    current = join(current, '..');
+                } else {
+                    break;
+                }
+            } catch {
+                break;
+            }
+        }
+    }
+}

package/src/naming.ts

@@ -0,0 +1,262 @@
+/**
+ * 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 const CSHARP_KEYWORDS: ReadonlySet<string> = new Set([
+    'abstract',
+    'as',
+    'base',
+    'bool',
+    'break',
+    'byte',
+    'case',
+    'catch',
+    'char',
+    'checked',
+    'class',
+    'const',
+    'continue',
+    'decimal',
+    'default',
+    'delegate',
+    'do',
+    'double',
+    'else',
+    'enum',
+    'event',
+    'explicit',
+    'extern',
+    'false',
+    'finally',
+    'fixed',
+    'float',
+    'for',
+    'foreach',
+    'goto',
+    'if',
+    'implicit',
+    'in',
+    'int',
+    'interface',
+    'internal',
+    'is',
+    'lock',
+    'long',
+    'namespace',
+    'new',
+    'null',
+    'object',
+    'operator',
+    'out',
+    'override',
+    'params',
+    'private',
+    'protected',
+    'public',
+    'readonly',
+    'ref',
+    'return',
+    'sbyte',
+    'sealed',
+    'short',
+    'sizeof',
+    'stackalloc',
+    'static',
+    'string',
+    'struct',
+    'switch',
+    'this',
+    'throw',
+    'true',
+    'try',
+    'typeof',
+    'uint',
+    'ulong',
+    'unchecked',
+    'unsafe',
+    'ushort',
+    'using',
+    'virtual',
+    'void',
+    'volatile',
+    'while',
+]);
+
+/**
+ * Members the C# compiler already declares on a record, plus the ones a record's synthesized
+ * members would collide with. A contract field landing on any of these has to be renamed.
+ */
+const RESERVED_MEMBER_NAMES: ReadonlySet<string> = new Set(['Equals', 'GetHashCode', 'GetType', 'ToString', 'EqualityContract', 'PrintMembers']);
+
+/**
+ * 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 function escapeCSharpIdentifier(name: string): string {
+    return CSHARP_KEYWORDS.has(name) ? `@${name}` : name;
+}
+
+/**
+ * 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 function toCSharpPropertyName(name: string): string {
+    const words = splitWords(name);
+    if (words.length === 0) return '_';
+    let result = words.map(capitalize).join('');
+    if (/^\d/.test(result)) result = `_${result}`;
+    return result;
+}
+
+/**
+ * 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 function toCSharpParameterName(name: string): string {
+    const words = splitWords(name);
+    if (words.length === 0) return '_';
+    const head = words[0]!.toLowerCase();
+    const rest = words.slice(1).map(capitalize);
+    let result = head + rest.join('');
+    if (/^\d/.test(result)) result = `_${result}`;
+    return escapeCSharpIdentifier(result);
+}
+
+/**
+ * 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 function safeMemberName(propertyName: string, ownerTypeName: string): string {
+    if (propertyName === ownerTypeName || RESERVED_MEMBER_NAMES.has(propertyName)) return `${propertyName}Value`;
+    return propertyName;
+}
+
+/**
+ * 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 function toCSharpTypeName(name: string): string {
+    const words = splitWords(name);
+    if (words.length === 0) return '_';
+    let result = words.map(capitalize).join('');
+    if (/^\d/.test(result)) result = `_${result}`;
+    return result;
+}
+
+/**
+ * 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 function sanitizeCSharpTypeName(name: string): string {
+    let result = name.replace(/[^a-zA-Z0-9]/g, '');
+    if (result.length === 0) return '_';
+    result = result.charAt(0).toUpperCase() + result.slice(1);
+    if (/^\d/.test(result)) result = `_${result}`;
+    return result;
+}
+
+/**
+ * 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 function toCSharpEnumMemberName(value: string): string {
+    const words = splitWords(value);
+    if (words.length === 0) return '_';
+    let result = words.map(capitalize).join('');
+    if (/^\d/.test(result)) result = `_${result}`;
+    return result;
+}
+
+/**
+ * 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 function deriveCSharpFileBase(file: string): string {
+    const base =
+        file
+            .split('/')
+            .pop()
+            ?.replace(/\.(op\.)?ck$/, '') ?? 'models';
+    return toCSharpTypeName(base);
+}
+
+/**
+ * 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 function xmlDocLines(text: string, indent: string, tag = 'summary'): string[] {
+    if (text.length === 0) return [];
+    const safe = escapeXml(text);
+    const sourceLines = safe.split('\n');
+    if (sourceLines.length === 1) return [`${indent}/// <${tag}>${sourceLines[0]}</${tag}>`];
+    return [`${indent}/// <${tag}>`, ...sourceLines.map(line => `${indent}/// ${line}`.trimEnd()), `${indent}/// </${tag}>`];
+}
+
+/** Escape the three characters that would otherwise make a doc comment malformed XML. */
+export function escapeXml(text: string): string {
+    return text.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}
+
+/**
+ * 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 function quoteCSharpString(value: string): string {
+    const escaped = value
+        .replace(/\\/g, '\\\\')
+        .replace(/"/g, '\\"')
+        .replace(/\n/g, '\\n')
+        .replace(/\r/g, '\\r')
+        .replace(/\t/g, '\\t')
+        .replace(/\0/g, '\\0');
+    return `"${escaped}"`;
+}
+
+/**
+ * Split an identifier into words on separators and camelCase boundaries.
+ * `"x-request-id"` becomes `["x", "request", "id"]`; `"createdAt"` becomes `["created", "At"]`;
+ * `"myHTTPClient"` becomes `["my", "HTTP", "Client"]`.
+ */
+function splitWords(name: string): string[] {
+    return name
+        .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+        .replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2')
+        .split(/[^a-zA-Z0-9]+/)
+        .filter(Boolean);
+}
+
+function capitalize(word: string): string {
+    return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
+}