@xrpckit/codegen 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,64 @@
+import { ContractDefinition } from '@xrpckit/parser';
+
+declare class CodeWriter {
+    private lines;
+    private indentLevel;
+    private indentString;
+    writeLine(text: string): this;
+    write(text: string): this;
+    indent(): this;
+    unindent(): this;
+    newLine(): this;
+    block(fn: () => void): this;
+    l(text: string): this;
+    n(): this;
+    i(): this;
+    u(): this;
+    brace(fn: () => void): this;
+    template(strings: TemplateStringsArray, ...values: unknown[]): this;
+    toString(): string;
+    reset(): this;
+}
+
+interface GeneratorConfig {
+    outputDir: string;
+    packageName?: string;
+    framework?: string;
+    options?: Record<string, unknown>;
+}
+interface GeneratedFiles {
+    types?: string;
+    server?: string;
+    client?: string;
+    validation?: string;
+}
+declare abstract class BaseCodeGenerator {
+    protected writer: CodeWriter;
+    protected config: GeneratorConfig;
+    constructor(config: GeneratorConfig);
+    abstract generate(contract: ContractDefinition): GeneratedFiles;
+    protected toPascalCase(str: string): string;
+    protected toCamelCase(str: string): string;
+    protected toSnakeCase(str: string): string;
+}
+
+/**
+ * Converts a string to PascalCase
+ * @param str - The string to convert (e.g., "hello-world" or "hello_world")
+ * @returns The PascalCase version (e.g., "HelloWorld")
+ */
+declare function toPascalCase(str: string): string;
+/**
+ * Converts a string to camelCase
+ * @param str - The string to convert
+ * @returns The camelCase version (e.g., "helloWorld")
+ */
+declare function toCamelCase(str: string): string;
+/**
+ * Converts a string to snake_case
+ * @param str - The string to convert
+ * @returns The snake_case version (e.g., "hello_world")
+ */
+declare function toSnakeCase(str: string): string;
+
+export { BaseCodeGenerator, CodeWriter, type GeneratedFiles, type GeneratorConfig, toCamelCase, toPascalCase, toSnakeCase };

package/dist/index.js

@@ -0,0 +1,116 @@
+// src/code-writer.ts
+var CodeWriter = class {
+  lines = [];
+  indentLevel = 0;
+  indentString = "    ";
+  // 4 spaces
+  // Main methods
+  writeLine(text) {
+    const indent = this.indentString.repeat(this.indentLevel);
+    this.lines.push(indent + text);
+    return this;
+  }
+  write(text) {
+    if (this.lines.length === 0) {
+      this.lines.push("");
+    }
+    const lastLine = this.lines[this.lines.length - 1];
+    this.lines[this.lines.length - 1] = lastLine + text;
+    return this;
+  }
+  indent() {
+    this.indentLevel++;
+    return this;
+  }
+  unindent() {
+    this.indentLevel = Math.max(0, this.indentLevel - 1);
+    return this;
+  }
+  newLine() {
+    this.lines.push("");
+    return this;
+  }
+  block(fn) {
+    this.writeLine("{");
+    this.indent();
+    fn();
+    this.unindent();
+    this.writeLine("}");
+    return this;
+  }
+  // Short aliases for more concise DSL
+  l(text) {
+    return this.writeLine(text);
+  }
+  n() {
+    return this.newLine();
+  }
+  i() {
+    return this.indent();
+  }
+  u() {
+    return this.unindent();
+  }
+  // Common patterns
+  brace(fn) {
+    return this.block(fn);
+  }
+  // Template literal support
+  template(strings, ...values) {
+    let result = "";
+    for (let i = 0; i < strings.length; i++) {
+      result += strings[i];
+      if (i < values.length) {
+        result += String(values[i]);
+      }
+    }
+    return this.writeLine(result);
+  }
+  toString() {
+    return this.lines.join("\n");
+  }
+  reset() {
+    this.lines = [];
+    this.indentLevel = 0;
+    return this;
+  }
+};
+
+// src/base-generator.ts
+var BaseCodeGenerator = class {
+  writer;
+  config;
+  constructor(config) {
+    this.writer = new CodeWriter();
+    this.config = config;
+  }
+  toPascalCase(str) {
+    return str.split(/[-_]/).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+  }
+  toCamelCase(str) {
+    const pascal = this.toPascalCase(str);
+    return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+  }
+  toSnakeCase(str) {
+    return str.replace(/([A-Z])/g, "_$1").toLowerCase();
+  }
+};
+
+// src/utils.ts
+function toPascalCase(str) {
+  return str.split(/[-_]/).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+}
+function toCamelCase(str) {
+  const pascal = toPascalCase(str);
+  return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
+function toSnakeCase(str) {
+  return str.replace(/([A-Z])/g, "_$1").toLowerCase();
+}
+export {
+  BaseCodeGenerator,
+  CodeWriter,
+  toCamelCase,
+  toPascalCase,
+  toSnakeCase
+};

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@xrpckit/codegen",
+  "version": "0.0.1",
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mwesox/xrpc.git",
+    "directory": "packages/codegen"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "bun": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean"
+  },
+  "dependencies": {
+    "@xrpckit/parser": "^0.0.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}