@game-infra/valibot-to-csharp 0.0.0

package/dist/generate.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Options accepted by {@link generate} and {@link generateToFile}.
+ *
+ * @example
+ * ```ts
+ * import type { GenerateOptions } from "@game-infra/valibot-to-csharp";
+ *
+ * const opts: GenerateOptions = {
+ *   inputs: ["./schemas/events.ts"],
+ *   outputDir: "./Generated",
+ *   namespace: "MyGame.Events",
+ * };
+ * ```
+ */
+export interface GenerateOptions {
+    /** Absolute or cwd-relative `.ts` files containing valibot schemas. */
+    inputs: string[];
+    /** Absolute or cwd-relative directory to write C# output into. */
+    outputDir: string;
+    /** C# namespace for emitted types. */
+    namespace: string;
+    /** When true, write a single bundled `.cs` file instead of one per input. */
+    bundle?: boolean;
+    /** Bundled file name (used when `bundle` is true). Default: 'Schemas.cs'. */
+    bundleName?: string;
+    /** Optional source-const → C# type name overrides (union/variant renames). */
+    unionRenames?: Record<string, string>;
+}
+/**
+ * One generated C# file: target path plus full file content.
+ *
+ * @example
+ * ```ts
+ * import { generate } from "@game-infra/valibot-to-csharp";
+ * import type { GeneratedFile } from "@game-infra/valibot-to-csharp";
+ *
+ * const result = await generate({
+ *   inputs: ["./schemas/events.ts"],
+ *   outputDir: "./Generated",
+ *   namespace: "MyGame.Events",
+ * });
+ * const file: GeneratedFile = result.files[0]!;
+ * console.log(file.path, file.content.length);
+ * ```
+ */
+export interface GeneratedFile {
+    path: string;
+    content: string;
+}
+/**
+ * Result of {@link generate} / {@link generateToFile}.
+ *
+ * @example
+ * ```ts
+ * import { generate } from "@game-infra/valibot-to-csharp";
+ * import type { GenerateResult } from "@game-infra/valibot-to-csharp";
+ *
+ * const result: GenerateResult = await generate({
+ *   inputs: ["./schemas/events.ts"],
+ *   outputDir: "./Generated",
+ *   namespace: "MyGame.Events",
+ * });
+ * ```
+ */
+export interface GenerateResult {
+    files: GeneratedFile[];
+}
+/**
+ * Parse the given TypeScript files, build the IR, and emit C# source. Returns
+ * the list of files that would be written (caller can inspect or persist via
+ * {@link generateToFile}).
+ *
+ * @example
+ * ```ts
+ * import { generate } from "@game-infra/valibot-to-csharp";
+ *
+ * const result = await generate({
+ *   inputs: ["./schemas/events.ts"],
+ *   outputDir: "./Generated",
+ *   namespace: "MyGame.Events",
+ * });
+ * for (const file of result.files) console.log(file.path);
+ * ```
+ */
+export declare function generate(opts: GenerateOptions): Promise<GenerateResult>;
+/**
+ * Run {@link generate} and write every returned file to disk.
+ *
+ * @example
+ * ```ts
+ * import { generateToFile } from "@game-infra/valibot-to-csharp";
+ *
+ * await generateToFile({
+ *   inputs: ["./schemas/events.ts"],
+ *   outputDir: "./Generated",
+ *   namespace: "MyGame.Events",
+ * });
+ * ```
+ */
+export declare function generateToFile(opts: GenerateOptions): Promise<GenerateResult>;
+//# sourceMappingURL=generate.d.ts.map

package/dist/generate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate.d.ts","sourceRoot":"","sources":["../src/generate.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,eAAe;IAC9B,uEAAuE;IACvE,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,kEAAkE;IAClE,SAAS,EAAE,MAAM,CAAC;IAClB,sCAAsC;IACtC,SAAS,EAAE,MAAM,CAAC;IAClB,6EAA6E;IAC7E,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,6EAA6E;IAC7E,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,8EAA8E;IAC9E,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACvC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,aAAa,EAAE,CAAC;CACxB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,QAAQ,CAAC,IAAI,EAAE,eAAe,GAAG,OAAO,CAAC,cAAc,CAAC,CAyC7E;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,cAAc,CAAC,IAAI,EAAE,eAAe,GAAG,OAAO,CAAC,cAAc,CAAC,CAOnF"}

package/dist/generate.js

@@ -0,0 +1,99 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { emitFileHeader, emitModule } from "./emitter.js";
+import { parseFiles } from "./parser.js";
+/**
+ * Parse the given TypeScript files, build the IR, and emit C# source. Returns
+ * the list of files that would be written (caller can inspect or persist via
+ * {@link generateToFile}).
+ *
+ * @example
+ * ```ts
+ * import { generate } from "@game-infra/valibot-to-csharp";
+ *
+ * const result = await generate({
+ *   inputs: ["./schemas/events.ts"],
+ *   outputDir: "./Generated",
+ *   namespace: "MyGame.Events",
+ * });
+ * for (const file of result.files) console.log(file.path);
+ * ```
+ */
+export async function generate(opts) {
+    const inputs = opts.inputs.map((f) => path.resolve(f));
+    const unionRenames = new Map(Object.entries(opts.unionRenames ?? {}));
+    if (opts.bundle) {
+        const module = parseFiles(inputs);
+        const emit = emitModule(module, {
+            namespace: opts.namespace,
+            unionRenames,
+        });
+        const header = emitFileHeader(module.notes);
+        const bundleName = opts.bundleName ?? "Schemas.cs";
+        return {
+            files: [
+                {
+                    path: path.resolve(opts.outputDir, bundleName),
+                    content: header + emit.source,
+                },
+            ],
+        };
+    }
+    // File-per-input mode: parse each entry (including its transitively imported
+    // local files) and emit all reachable schemas into a single .cs file named
+    // after the entry. Per the spec, cross-file references get pulled into the
+    // same output file so the resulting C# compiles standalone.
+    const files = [];
+    for (const input of inputs) {
+        const module = parseFiles([input]);
+        const emit = emitModule(module, {
+            namespace: opts.namespace,
+            unionRenames,
+        });
+        const header = emitFileHeader(module.notes);
+        const csFileName = toCsFileName(input);
+        files.push({
+            path: path.resolve(opts.outputDir, csFileName),
+            content: header + emit.source,
+        });
+    }
+    return { files };
+}
+/**
+ * Run {@link generate} and write every returned file to disk.
+ *
+ * @example
+ * ```ts
+ * import { generateToFile } from "@game-infra/valibot-to-csharp";
+ *
+ * await generateToFile({
+ *   inputs: ["./schemas/events.ts"],
+ *   outputDir: "./Generated",
+ *   namespace: "MyGame.Events",
+ * });
+ * ```
+ */
+export async function generateToFile(opts) {
+    const result = await generate(opts);
+    for (const f of result.files) {
+        fs.mkdirSync(path.dirname(f.path), { recursive: true });
+        fs.writeFileSync(f.path, f.content, "utf8");
+    }
+    return result;
+}
+function toCsFileName(tsInput) {
+    const base = path.basename(tsInput).replace(/\.(ts|tsx)$/i, "");
+    // Mirror C# convention: PascalCase filename, and normalise DTO → Dto so
+    // the output file doesn't scream the acronym.
+    const parts = base
+        .replace(/[^A-Za-z0-9]+/g, " ")
+        .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+        .trim()
+        .split(/\s+/);
+    const pascal = parts
+        .map((p) => (p.length === 0 ? "" : p[0].toUpperCase() + p.slice(1)))
+        .join("")
+        .replace(/DTO/g, "Dto");
+    return `${pascal}.cs`;
+}
+//# sourceMappingURL=generate.js.map

package/dist/generate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate.js","sourceRoot":"","sources":["../src/generate.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Public entry point for `@game-infra/valibot-to-csharp`.
+ *
+ * High-level API: {@link generate} / {@link generateToFile}. Lower-level
+ * building blocks ({@link parseFiles}, {@link emitModule}, the IR types) are
+ * exported for consumers embedding the generator into their own pipelines.
+ */
+export { generate, generateToFile } from "./generate.js";
+export type { GeneratedFile, GenerateOptions, GenerateResult } from "./generate.js";
+export { emitFileHeader, emitModule } from "./emitter.js";
+export type { EmitOptions, EmitResult } from "./emitter.js";
+export { parseFiles } from "./parser.js";
+export type { ArrayNode, LiteralNode, NamedSchema, NullableNode, ObjectField, ObjectNode, OptionalNode, PicklistNode, PrimitiveNode, RecordNode, RefNode, SchemaModule, SchemaNode, UnionNode, UnknownNode, VariantNode, } from "./ir.js";
+export { csStringLiteral, indent, stripSchemaSuffix, toPascalCase } from "./naming.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AACzD,YAAY,EAAE,aAAa,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AACpF,OAAO,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1D,YAAY,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC5D,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACzC,YAAY,EACV,SAAS,EACT,WAAW,EACX,WAAW,EACX,YAAY,EACZ,WAAW,EACX,UAAU,EACV,YAAY,EACZ,YAAY,EACZ,aAAa,EACb,UAAU,EACV,OAAO,EACP,YAAY,EACZ,UAAU,EACV,SAAS,EACT,WAAW,EACX,WAAW,GACZ,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,eAAe,EAAE,MAAM,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC"}

package/dist/index.js

@@ -0,0 +1,12 @@
+/**
+ * Public entry point for `@game-infra/valibot-to-csharp`.
+ *
+ * High-level API: {@link generate} / {@link generateToFile}. Lower-level
+ * building blocks ({@link parseFiles}, {@link emitModule}, the IR types) are
+ * exported for consumers embedding the generator into their own pipelines.
+ */
+export { generate, generateToFile } from "./generate.js";
+export { emitFileHeader, emitModule } from "./emitter.js";
+export { parseFiles } from "./parser.js";
+export { csStringLiteral, indent, stripSchemaSuffix, toPascalCase } from "./naming.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAEzD,OAAO,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE1D,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAmBzC,OAAO,EAAE,eAAe,EAAE,MAAM,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC"}

package/dist/ir.d.ts

@@ -0,0 +1,292 @@
+/**
+ * Intermediate representation produced by the parser and consumed by the
+ * emitter.
+ *
+ * A valibot source file is reduced to a list of named schemas that each
+ * describe an object/record, a picklist/enum, a discriminated union, or a
+ * plain type alias. The shape is intentionally closed: if a new valibot
+ * feature is needed, extend {@link SchemaNode} and teach the emitter how to
+ * handle it.
+ */
+/**
+ * Union of every schema node the parser can produce. Narrow on `kind`.
+ *
+ * @example
+ * ```ts
+ * import type { SchemaNode } from "@game-infra/valibot-to-csharp";
+ *
+ * function describe(node: SchemaNode): string {
+ *   return node.kind === "array" ? `array of ${node.inner.kind}` : node.kind;
+ * }
+ * ```
+ */
+export type SchemaNode = PrimitiveNode | UnknownNode | ArrayNode | RecordNode | ObjectNode | LiteralNode | PicklistNode | UnionNode | VariantNode | RefNode | NullableNode | OptionalNode;
+/**
+ * A valibot `string()`, `number()`, or `boolean()` call.
+ *
+ * @example
+ * ```ts
+ * import type { PrimitiveNode } from "@game-infra/valibot-to-csharp";
+ *
+ * const node: PrimitiveNode = { kind: "primitive", type: "string" };
+ * ```
+ */
+export interface PrimitiveNode {
+    kind: "primitive";
+    type: "string" | "number" | "boolean";
+}
+/**
+ * A valibot `unknown()` call. Emitted as `JsonElement` in C#.
+ *
+ * @example
+ * ```ts
+ * import type { UnknownNode } from "@game-infra/valibot-to-csharp";
+ *
+ * const node: UnknownNode = { kind: "unknown" };
+ * ```
+ */
+export interface UnknownNode {
+    kind: "unknown";
+}
+/**
+ * A valibot `array(inner)` call. Emitted as `IReadOnlyList<T>` in C#.
+ *
+ * @example
+ * ```ts
+ * import type { ArrayNode } from "@game-infra/valibot-to-csharp";
+ *
+ * const node: ArrayNode = {
+ *   kind: "array",
+ *   inner: { kind: "primitive", type: "string" },
+ * };
+ * ```
+ */
+export interface ArrayNode {
+    kind: "array";
+    inner: SchemaNode;
+}
+/**
+ * A valibot `record(string(), value)` call. Only string keys are supported.
+ * Emitted as `IReadOnlyDictionary<string, T>` in C#.
+ *
+ * @example
+ * ```ts
+ * import type { RecordNode } from "@game-infra/valibot-to-csharp";
+ *
+ * const node: RecordNode = { kind: "record", value: { kind: "unknown" } };
+ * ```
+ */
+export interface RecordNode {
+    kind: "record";
+    value: SchemaNode;
+}
+/**
+ * A single field of an {@link ObjectNode}. `optional`/`nullable` wrappers are
+ * peeled off the field schema and tracked here as flags.
+ *
+ * @example
+ * ```ts
+ * import type { ObjectField } from "@game-infra/valibot-to-csharp";
+ *
+ * const field: ObjectField = {
+ *   name: "title",
+ *   schema: { kind: "primitive", type: "string" },
+ *   optional: false,
+ *   nullable: false,
+ * };
+ * ```
+ */
+export interface ObjectField {
+    name: string;
+    schema: SchemaNode;
+    optional: boolean;
+    nullable: boolean;
+}
+/**
+ * A valibot `object({...})` call. Emitted as a `public sealed record` in C#.
+ *
+ * @example
+ * ```ts
+ * import type { ObjectNode } from "@game-infra/valibot-to-csharp";
+ *
+ * const node: ObjectNode = {
+ *   kind: "object",
+ *   fields: [
+ *     {
+ *       name: "id",
+ *       schema: { kind: "primitive", type: "string" },
+ *       optional: false,
+ *       nullable: false,
+ *     },
+ *   ],
+ * };
+ * ```
+ */
+export interface ObjectNode {
+    kind: "object";
+    fields: ObjectField[];
+}
+/**
+ * A valibot `literal("a")` call. Only string literals are supported; they get
+ * merged into enums or variant discriminator tags.
+ *
+ * @example
+ * ```ts
+ * import type { LiteralNode } from "@game-infra/valibot-to-csharp";
+ *
+ * const node: LiteralNode = { kind: "literal", value: "ShowMessage" };
+ * ```
+ */
+export interface LiteralNode {
+    kind: "literal";
+    value: string;
+}
+/**
+ * A valibot `picklist(["a", "b"])` call. Emitted as a string-serialised C#
+ * enum.
+ *
+ * @example
+ * ```ts
+ * import type { PicklistNode } from "@game-infra/valibot-to-csharp";
+ *
+ * const node: PicklistNode = { kind: "picklist", values: ["common", "rare"] };
+ * ```
+ */
+export interface PicklistNode {
+    kind: "picklist";
+    values: string[];
+}
+/**
+ * A valibot `union([...])` call. The emitter classifies the members into an
+ * enum, a string-or-string-list helper, a discriminated union, or a
+ * `JsonElement` fallback.
+ *
+ * @example
+ * ```ts
+ * import type { UnionNode } from "@game-infra/valibot-to-csharp";
+ *
+ * const node: UnionNode = {
+ *   kind: "union",
+ *   members: [
+ *     { kind: "literal", value: "a" },
+ *     { kind: "literal", value: "b" },
+ *   ],
+ * };
+ * ```
+ */
+export interface UnionNode {
+    kind: "union";
+    members: SchemaNode[];
+}
+/**
+ * A valibot `variant("type", [...])` call. Emitted as a `[JsonPolymorphic]`
+ * abstract record with one derived record per member.
+ *
+ * @example
+ * ```ts
+ * import type { VariantNode } from "@game-infra/valibot-to-csharp";
+ *
+ * const node: VariantNode = {
+ *   kind: "variant",
+ *   discriminator: "type",
+ *   members: [{ kind: "ref", name: "ShowMessageSchema" }],
+ * };
+ * ```
+ */
+export interface VariantNode {
+    kind: "variant";
+    discriminator: string;
+    members: SchemaNode[];
+}
+/**
+ * A bare identifier referencing another named schema, e.g. `RaritySchema`
+ * used inside an `object({...})`.
+ *
+ * @example
+ * ```ts
+ * import type { RefNode } from "@game-infra/valibot-to-csharp";
+ *
+ * const node: RefNode = { kind: "ref", name: "RaritySchema" };
+ * ```
+ */
+export interface RefNode {
+    kind: "ref";
+    name: string;
+}
+/**
+ * A valibot `nullable(inner)` call. On object fields this is peeled into the
+ * {@link ObjectField} `nullable` flag.
+ *
+ * @example
+ * ```ts
+ * import type { NullableNode } from "@game-infra/valibot-to-csharp";
+ *
+ * const node: NullableNode = {
+ *   kind: "nullable",
+ *   inner: { kind: "primitive", type: "number" },
+ * };
+ * ```
+ */
+export interface NullableNode {
+    kind: "nullable";
+    inner: SchemaNode;
+}
+/**
+ * A valibot `optional(inner)` call. On object fields this is peeled into the
+ * {@link ObjectField} `optional` flag.
+ *
+ * @example
+ * ```ts
+ * import type { OptionalNode } from "@game-infra/valibot-to-csharp";
+ *
+ * const node: OptionalNode = {
+ *   kind: "optional",
+ *   inner: { kind: "primitive", type: "string" },
+ * };
+ * ```
+ */
+export interface OptionalNode {
+    kind: "optional";
+    inner: SchemaNode;
+}
+/**
+ * One parsed `export const XSchema = ...` declaration.
+ *
+ * @example
+ * ```ts
+ * import type { NamedSchema } from "@game-infra/valibot-to-csharp";
+ *
+ * const named: NamedSchema = {
+ *   name: "RaritySchema",
+ *   sourceFile: "/abs/path/schemas.ts",
+ *   schema: { kind: "picklist", values: ["common", "rare"] },
+ * };
+ * ```
+ */
+export interface NamedSchema {
+    /** Source const name, e.g. "EventDefinitionDTOSchema". */
+    name: string;
+    /** Source file this schema came from (absolute). */
+    sourceFile: string;
+    schema: SchemaNode;
+}
+/**
+ * The parse result for a set of input files: every named schema found, plus
+ * notes surfaced by parser heuristics.
+ *
+ * @example
+ * ```ts
+ * import { parseFiles } from "@game-infra/valibot-to-csharp";
+ * import type { SchemaModule } from "@game-infra/valibot-to-csharp";
+ *
+ * const module: SchemaModule = parseFiles(["./schemas/events.ts"]);
+ * console.log([...module.schemas.keys()]);
+ * ```
+ */
+export interface SchemaModule {
+    /** Map of source const name to parsed schema. */
+    schemas: Map<string, NamedSchema>;
+    /** Flags surfaced by parser heuristics (e.g. the string('x') as literal hack). */
+    notes: string[];
+}
+//# sourceMappingURL=ir.d.ts.map

package/dist/ir.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ir.d.ts","sourceRoot":"","sources":["../src/ir.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,UAAU,GAClB,aAAa,GACb,WAAW,GACX,SAAS,GACT,UAAU,GACV,UAAU,GACV,WAAW,GACX,YAAY,GACZ,SAAS,GACT,WAAW,GACX,OAAO,GACP,YAAY,GACZ,YAAY,CAAC;AAEjB;;;;;;;;;GASG;AACH,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,WAAW,CAAC;IAClB,IAAI,EAAE,QAAQ,GAAG,QAAQ,GAAG,SAAS,CAAC;CACvC;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,SAAS,CAAC;CACjB;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,OAAO,CAAC;IACd,KAAK,EAAE,UAAU,CAAC;CACnB;AAED;;;;;;;;;;GAUG;AACH,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,QAAQ,CAAC;IACf,KAAK,EAAE,UAAU,CAAC;CACnB;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,UAAU,CAAC;IACnB,QAAQ,EAAE,OAAO,CAAC;IAClB,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,QAAQ,CAAC;IACf,MAAM,EAAE,WAAW,EAAE,CAAC;CACvB;AAED;;;;;;;;;;GAUG;AACH,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,SAAS,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;;;;GAUG;AACH,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,UAAU,CAAC;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,OAAO,CAAC;IACd,OAAO,EAAE,UAAU,EAAE,CAAC;CACvB;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,SAAS,CAAC;IAChB,aAAa,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE,UAAU,EAAE,CAAC;CACvB;AAED;;;;;;;;;;GAUG;AACH,MAAM,WAAW,OAAO;IACtB,IAAI,EAAE,KAAK,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,UAAU,CAAC;IACjB,KAAK,EAAE,UAAU,CAAC;CACnB;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,UAAU,CAAC;IACjB,KAAK,EAAE,UAAU,CAAC;CACnB;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,WAAW;IAC1B,0DAA0D;IAC1D,IAAI,EAAE,MAAM,CAAC;IACb,oDAAoD;IACpD,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,UAAU,CAAC;CACpB;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,YAAY;IAC3B,iDAAiD;IACjD,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;IAClC,kFAAkF;IAClF,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB"}

package/dist/ir.js

@@ -0,0 +1,12 @@
+/**
+ * Intermediate representation produced by the parser and consumed by the
+ * emitter.
+ *
+ * A valibot source file is reduced to a list of named schemas that each
+ * describe an object/record, a picklist/enum, a discriminated union, or a
+ * plain type alias. The shape is intentionally closed: if a new valibot
+ * feature is needed, extend {@link SchemaNode} and teach the emitter how to
+ * handle it.
+ */
+export {};
+//# sourceMappingURL=ir.js.map

package/dist/ir.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ir.js","sourceRoot":"","sources":["../src/ir.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG"}

package/dist/naming.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Small naming helpers shared by the parser and the emitter.
+ */
+/**
+ * Convert arbitrary identifiers / string enum values into PascalCase.
+ *
+ * @example
+ * ```ts
+ * import { toPascalCase } from "@game-infra/valibot-to-csharp";
+ *
+ * toPascalCase("fooBar"); // "FooBar"
+ * toPascalCase("foo_bar-baz"); // "FooBarBaz"
+ * toPascalCase("EventDTO"); // "EventDto"
+ * ```
+ */
+export declare function toPascalCase(input: string): string;
+/**
+ * Strip the trailing "Schema" suffix from a valibot const name and normalise
+ * common acronyms (DTO → Dto). Returns a PascalCase C# type name.
+ *
+ * @example
+ * ```ts
+ * import { stripSchemaSuffix } from "@game-infra/valibot-to-csharp";
+ *
+ * stripSchemaSuffix("FooSchema"); // "Foo"
+ * stripSchemaSuffix("EventDefinitionDTOSchema"); // "EventDefinitionDto"
+ * stripSchemaSuffix("fooBarSchema"); // "FooBar"
+ * ```
+ */
+export declare function stripSchemaSuffix(name: string): string;
+/**
+ * Escape a C# string literal (for JsonPropertyName values etc.).
+ *
+ * @example
+ * ```ts
+ * import { csStringLiteral } from "@game-infra/valibot-to-csharp";
+ *
+ * csStringLiteral('a"b\\c'); // '"a\\"b\\\\c"'
+ * ```
+ */
+export declare function csStringLiteral(value: string): string;
+/**
+ * Indent every non-empty line of `text` by `spaces` spaces.
+ *
+ * @example
+ * ```ts
+ * import { indent } from "@game-infra/valibot-to-csharp";
+ *
+ * indent("a\nb", 4); // "    a\n    b"
+ * ```
+ */
+export declare function indent(text: string, spaces: number): 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;;GAEG;AAOH;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAYlD;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAatD;AAED;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAErD;AAED;;;;;;;;;GASG;AACH,wBAAgB,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAM3D"}