@f3liz/rescript-autogen-openapi 0.1.5 → 0.1.7

package/README.md

@@ -9,12 +9,25 @@ Generate ReScript code with [Sury](https://github.com/DZakh/rescript-schema) sch
 *   **Multi-Fork Support**: Intelligently handles multiple API forks (like Misskey, Cherrypick, Firefish) by extracting shared code and generating fork-specific extensions.
 *   **Unified IR Pipeline**: Advanced type inference with a unified intermediate representation that generates both types and schemas.
 *   **Diff & Merge**: Compare specs, generate diff reports, and optimize code reuse across variants.
-*   **TypeScript Support**: Generates `.d.ts` files and TypeScript wrappers for idiomatic use in JS/TS projects.
+*   **TypeScript Support**: First-class TypeScript support via `genType`. Exported functions and types are idiomatic and fully typed for use in TypeScript projects.
 
 ## 📦 Installation
 
 ```bash
-npm install @f3liz/rescript-autogen-openapi sury @readme/openapi-parser
+npm install @f3liz/rescript-autogen-openapi sury
+```
+
+**Important**: This library has a peer dependency on `sury` (ReScript Schema). You must install it in your project because the generated code directly depends on it for runtime validation.
+
+### Configure `rescript.json`
+
+Add `sury` to your project dependencies:
+
+```json
+{
+  "name": "my-project",
+  "dependencies": ["sury"]
+}
 ```
 
 Ensure you have `rescript` (^12.0.0) installed.

package/lib/es6/src/Codegen.d.ts

@@ -0,0 +1,28 @@
+import type { codegenError as Types_codegenError } from './Types';
+import type { forkSpec as Types_forkSpec } from './Types';
+import type { generationConfig as Types_generationConfig } from './Types';
+import type { generationResult as Types_generationResult } from './Types';
+import type { openAPISpec as Types_openAPISpec } from './Types';
+import type { specDiff as Types_specDiff } from './Types';
+import type { t as Pipeline_t } from './core/Pipeline';
+export declare const generateSingleSpecPure: (spec: Types_openAPISpec, config: Types_generationConfig) => {
+    TAG: "Ok";
+    _0: Pipeline_t;
+} | {
+    TAG: "Error";
+    _0: Types_codegenError;
+};
+export declare const generateSingleSpec: (spec: Types_openAPISpec, config: Types_generationConfig) => Promise<Types_generationResult>;
+export declare const generateMultiSpecPure: (baseSpec: Types_openAPISpec, forkSpecs: Types_forkSpec[], config: Types_generationConfig) => {
+    TAG: "Ok";
+    _0: Pipeline_t;
+} | {
+    TAG: "Error";
+    _0: Types_codegenError;
+};
+export declare const generateMultiSpec: (baseSpec: Types_openAPISpec, forkSpecs: Types_forkSpec[], config: Types_generationConfig) => Promise<Types_generationResult>;
+export declare const compareSpecs: (baseSpec: Types_openAPISpec, forkSpec: Types_openAPISpec, baseName: (undefined | string), forkName: (undefined | string), outputPath: (undefined | string)) => Promise<Types_specDiff>;
+export declare const generate: (config: Types_generationConfig) => Promise<Types_generationResult>;
+export declare const createDefaultConfig: (url: string, outputDir: string) => Types_generationConfig;
+export declare const generateFromUrl: (url: string, outputDir: string, config: (undefined | Types_generationConfig)) => Promise<Types_generationResult>;
+export declare const generateFromFile: (filePath: string, outputDir: string, config: (undefined | Types_generationConfig)) => Promise<Types_generationResult>;

package/lib/es6/src/Codegen.mjs

@@ -2,7 +2,6 @@
 
 import * as Config from "./types/Config.mjs";
 import * as Pipeline from "./core/Pipeline.mjs";
-import * as Text from "@std/text";
 import * as Belt_Array from "@rescript/runtime/lib/es6/Belt_Array.js";
 import * as FileSystem from "./core/FileSystem.mjs";
 import * as SpecDiffer from "./core/SpecDiffer.mjs";
@@ -14,6 +13,7 @@ import * as OpenAPIParser from "./core/OpenAPIParser.mjs";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Stdlib_Result from "@rescript/runtime/lib/es6/Stdlib_Result.js";
 import * as ModuleGenerator from "./generators/ModuleGenerator.mjs";
+import * as JsConvertCase from "js-convert-case";
 import * as SchemaRefResolver from "./core/SchemaRefResolver.mjs";
 import * as DiffReportGenerator from "./generators/DiffReportGenerator.mjs";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
@@ -32,7 +32,7 @@ function generateSingleSpecPure(spec, config) {
         ComponentSchemaGenerator.generate(spec, config.outputDir),
         config.modulePerTag ? ModuleGenerator.generateTagModuleFiles(endpoints, config.outputDir, undefined, config.docOverrideDir) : ModuleGenerator.generateFlatModuleFile("API", endpoints, config.outputDir, config.docOverrideDir)
       ]) : Pipeline.empty;
-    let wrapperOutput = targets.rescriptWrapper ? ThinWrapperGenerator.generateWrapper(spec, endpoints, undefined, config.outputDir, Text.toPascalCase(spec.info.title) + "Wrapper", "", undefined) : Pipeline.empty;
+    let wrapperOutput = targets.rescriptWrapper ? ThinWrapperGenerator.generateWrapper(spec, endpoints, undefined, config.outputDir, JsConvertCase.toPascalCase(spec.info.title) + "Wrapper", "", undefined) : Pipeline.empty;
     let dtsOutput = targets.typescriptDts ? TypeScriptDtsGenerator.generate(spec, endpoints, Stdlib_Option.getOr(config.dtsOutputDir, config.outputDir)) : Pipeline.empty;
     let tsWrapperOutput = targets.typescriptWrapper ? TypeScriptWrapperGenerator.generate(endpoints, Stdlib_Option.getOr(config.wrapperOutputDir, config.outputDir), "../generated") : Pipeline.empty;
     return {
@@ -136,11 +136,11 @@ function processForkPure(baseSpec, baseEndpoints, fork, config) {
     if (match$1 === "Separate") {
       codeOutput = Pipeline.fromFile({
         path: FileSystem.makePath(config.outputDir, fork.name + `.res`),
-        content: ModuleGenerator.generateFlatModuleCode(Text.toPascalCase(fork.name), forkEndpoints, config.docOverrideDir)
+        content: ModuleGenerator.generateFlatModuleCode(JsConvertCase.toPascalCase(fork.name), forkEndpoints, config.docOverrideDir)
       });
     } else {
       let baseName = Stdlib_Option.getOrThrow(config.baseInstanceName, "baseInstanceName required");
-      let basePrefix = Stdlib_Option.getOr(config.baseModulePrefix, Text.toPascalCase(baseName));
+      let basePrefix = Stdlib_Option.getOr(config.baseModulePrefix, JsConvertCase.toPascalCase(baseName));
       codeOutput = ModuleGenerator.generateSeparatePerTagModules(baseName, basePrefix, fork.name, undefined, sharedEndpoints, extensionEndpoints, Stdlib_Option.flatMap(sharedSpec.components, c => c.schemas), Stdlib_Option.flatMap(fork.spec.components, c => c.schemas), config.outputDir, config.docOverrideDir);
     }
     let targets = Stdlib_Option.getOr(config.targets, {
@@ -160,12 +160,12 @@ function processForkPure(baseSpec, baseEndpoints, fork, config) {
         sharedSpec,
         sharedEndpoints,
         extensionEndpoints,
-        Stdlib_Option.getOr(config.baseModulePrefix, Stdlib_Option.getOr(Stdlib_Option.map(config.baseInstanceName, prim => Text.toPascalCase(prim)), ""))
+        Stdlib_Option.getOr(config.baseModulePrefix, Stdlib_Option.getOr(Stdlib_Option.map(config.baseInstanceName, prim => JsConvertCase.toPascalCase(prim)), ""))
       ];
     let wExt = match$3[2];
     let wShared = match$3[1];
     let wSpec = match$3[0];
-    let wrapperOutput = targets.rescriptWrapper ? ThinWrapperGenerator.generateWrapper(wSpec, wShared, wExt, FileSystem.makePath(config.outputDir, fork.name), Text.toPascalCase(fork.name) + "Wrapper", Text.toPascalCase(fork.name), match$3[3]) : Pipeline.empty;
+    let wrapperOutput = targets.rescriptWrapper ? ThinWrapperGenerator.generateWrapper(wSpec, wShared, wExt, FileSystem.makePath(config.outputDir, fork.name), JsConvertCase.toPascalCase(fork.name) + "Wrapper", JsConvertCase.toPascalCase(fork.name), match$3[3]) : Pipeline.empty;
     let allWEndpoints = wShared.concat(wExt);
     let dtsOutput = targets.typescriptDts ? TypeScriptDtsGenerator.generate(wSpec, allWEndpoints, FileSystem.makePath(Stdlib_Option.getOr(config.dtsOutputDir, config.outputDir), fork.name)) : Pipeline.empty;
     let tsWrapperOutput = targets.typescriptWrapper ? TypeScriptWrapperGenerator.generate(allWEndpoints, FileSystem.makePath(Stdlib_Option.getOr(config.wrapperOutputDir, config.outputDir), fork.name), `../../generated/` + fork.name) : Pipeline.empty;
@@ -232,7 +232,7 @@ function generateMultiSpecPure(baseSpec, forkSpecs, config) {
       });
       let targets = Stdlib_Option.getOr(config.targets, Config.defaultTargets());
       let baseName = Stdlib_Option.getOrThrow(config.baseInstanceName, "baseInstanceName required");
-      let basePrefix = Stdlib_Option.getOr(config.baseModulePrefix, Text.toPascalCase(baseName));
+      let basePrefix = Stdlib_Option.getOr(config.baseModulePrefix, JsConvertCase.toPascalCase(baseName));
       let baseOutputDir = FileSystem.makePath(config.outputDir, baseName);
       let baseWrappers = Pipeline.combine([
         targets.rescriptWrapper ? ThinWrapperGenerator.generateWrapper(baseSpec, baseEndpoints, undefined, baseOutputDir, basePrefix + "Wrapper", basePrefix, undefined) : Pipeline.empty,
@@ -420,4 +420,4 @@ export {
   generateFromUrl,
   generateFromFile,
 }
-/* @std/text Not a pure module */
+/* FileSystem Not a pure module */

package/lib/es6/src/Types.d.ts

@@ -0,0 +1,286 @@
+import type { t as Config_t } from './types/Config';
+export type jsonSchemaType = "String" | "Number" | "Integer" | "Boolean" | "Object" | "Null" | "Unknown" | {
+    TAG: "Array";
+    _0: jsonSchemaType;
+};
+export type jsonSchema = {
+    readonly type: (undefined | jsonSchemaType);
+    readonly properties: (undefined | {
+        [id: string]: jsonSchema;
+    });
+    readonly items: (undefined | jsonSchema);
+    readonly required: (undefined | string[]);
+    readonly enum: (undefined | unknown[]);
+    readonly "$ref": (undefined | string);
+    readonly allOf: (undefined | jsonSchema[]);
+    readonly oneOf: (undefined | jsonSchema[]);
+    readonly anyOf: (undefined | jsonSchema[]);
+    readonly description: (undefined | string);
+    readonly format: (undefined | string);
+    readonly minLength: (undefined | number);
+    readonly maxLength: (undefined | number);
+    readonly minimum: (undefined | number);
+    readonly maximum: (undefined | number);
+    readonly pattern: (undefined | string);
+    readonly nullable: (undefined | boolean);
+};
+export type httpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "HEAD" | "OPTIONS";
+export type mediaType = {
+    readonly schema: (undefined | jsonSchema);
+    readonly example: (undefined | unknown);
+    readonly examples: (undefined | {
+        [id: string]: unknown;
+    });
+};
+export type requestBody = {
+    readonly description: (undefined | string);
+    readonly content: {
+        [id: string]: mediaType;
+    };
+    readonly required: (undefined | boolean);
+};
+export type response = {
+    readonly description: string;
+    readonly content: (undefined | {
+        [id: string]: mediaType;
+    });
+};
+export type parameter = {
+    readonly name: string;
+    readonly in: string;
+    readonly description: (undefined | string);
+    readonly required: (undefined | boolean);
+    readonly schema: (undefined | jsonSchema);
+};
+export type operation = {
+    readonly operationId: (undefined | string);
+    readonly summary: (undefined | string);
+    readonly description: (undefined | string);
+    readonly tags: (undefined | string[]);
+    readonly requestBody: (undefined | requestBody);
+    readonly responses: {
+        [id: string]: response;
+    };
+    readonly parameters: (undefined | parameter[]);
+};
+export type endpoint = {
+    readonly path: string;
+    readonly method: string;
+    readonly operationId: (undefined | string);
+    readonly summary: (undefined | string);
+    readonly description: (undefined | string);
+    readonly tags: (undefined | string[]);
+    readonly requestBody: (undefined | requestBody);
+    readonly responses: {
+        [id: string]: response;
+    };
+    readonly parameters: (undefined | parameter[]);
+};
+export type pathItem = {
+    readonly get: (undefined | operation);
+    readonly post: (undefined | operation);
+    readonly put: (undefined | operation);
+    readonly patch: (undefined | operation);
+    readonly delete: (undefined | operation);
+    readonly head: (undefined | operation);
+    readonly options: (undefined | operation);
+    readonly parameters: (undefined | parameter[]);
+};
+export type components = {
+    readonly schemas: (undefined | {
+        [id: string]: jsonSchema;
+    });
+};
+export type info = {
+    readonly title: string;
+    readonly version: string;
+    readonly description: (undefined | string);
+};
+export type openAPISpec = {
+    readonly openapi: string;
+    readonly info: info;
+    readonly paths: {
+        [id: string]: pathItem;
+    };
+    readonly components: (undefined | components);
+};
+export type generationStrategy = "Separate" | "SharedBase";
+export type breakingChangeHandling = "Error" | "Warn" | "Ignore";
+export type forkSpecConfig = {
+    readonly name: string;
+    readonly specPath: string;
+};
+export type generationTargets = {
+    readonly rescriptApi: boolean;
+    readonly rescriptWrapper: boolean;
+    readonly typescriptDts: boolean;
+    readonly typescriptWrapper: boolean;
+};
+export type generationConfig = Config_t;
+export type forkSpec = {
+    readonly name: string;
+    readonly spec: openAPISpec;
+};
+export type errorContext = {
+    readonly path: string;
+    readonly operation: string;
+    readonly schema: (undefined | unknown);
+};
+export type codegenError = {
+    TAG: "SpecResolutionError";
+    readonly url: string;
+    readonly message: string;
+} | {
+    TAG: "SchemaParseError";
+    readonly context: errorContext;
+    readonly reason: string;
+} | {
+    TAG: "ReferenceError";
+    readonly ref: string;
+    readonly context: errorContext;
+} | {
+    TAG: "ValidationError";
+    readonly schema: string;
+    readonly input: unknown;
+    readonly issues: string[];
+} | {
+    TAG: "CircularSchemaError";
+    readonly ref: string;
+    readonly depth: number;
+    readonly path: string;
+} | {
+    TAG: "FileWriteError";
+    readonly filePath: string;
+    readonly message: string;
+} | {
+    TAG: "InvalidConfigError";
+    readonly field: string;
+    readonly message: string;
+} | {
+    TAG: "UnknownError";
+    readonly message: string;
+    readonly context: (undefined | errorContext);
+};
+export type warning = {
+    TAG: "FallbackToJson";
+    readonly reason: string;
+    readonly context: errorContext;
+} | {
+    TAG: "UnsupportedFeature";
+    readonly feature: string;
+    readonly fallback: string;
+    readonly location: string;
+} | {
+    TAG: "DepthLimitReached";
+    readonly depth: number;
+    readonly path: string;
+} | {
+    TAG: "MissingSchema";
+    readonly ref: string;
+    readonly location: string;
+} | {
+    TAG: "IntersectionNotFullySupported";
+    readonly location: string;
+    readonly note: string;
+} | {
+    TAG: "ComplexUnionSimplified";
+    readonly location: string;
+    readonly types: string;
+};
+export type endpointDiff = {
+    readonly path: string;
+    readonly method: string;
+    readonly requestBodyChanged: boolean;
+    readonly responseChanged: boolean;
+    readonly breakingChange: boolean;
+};
+export type schemaDiff = {
+    readonly name: string;
+    readonly breakingChange: boolean;
+};
+export type specDiff = {
+    readonly addedEndpoints: endpoint[];
+    readonly removedEndpoints: endpoint[];
+    readonly modifiedEndpoints: endpointDiff[];
+    readonly addedSchemas: string[];
+    readonly removedSchemas: string[];
+    readonly modifiedSchemas: schemaDiff[];
+};
+export type generationSuccess = {
+    readonly generatedFiles: string[];
+    readonly diff: (undefined | specDiff);
+    readonly warnings: warning[];
+};
+export type generationResult = {
+    TAG: "Ok";
+    _0: generationSuccess;
+} | {
+    TAG: "Error";
+    _0: codegenError;
+};
+export type CodegenError_context = {
+    readonly path: string;
+    readonly operation: string;
+    readonly schema: (undefined | unknown);
+};
+export type CodegenError_t = {
+    TAG: "SpecResolutionError";
+    readonly url: string;
+    readonly message: string;
+} | {
+    TAG: "SchemaParseError";
+    readonly context: CodegenError_context;
+    readonly reason: string;
+} | {
+    TAG: "ReferenceError";
+    readonly ref: string;
+    readonly context: CodegenError_context;
+} | {
+    TAG: "ValidationError";
+    readonly schema: string;
+    readonly input: unknown;
+    readonly issues: string[];
+} | {
+    TAG: "CircularSchemaError";
+    readonly ref: string;
+    readonly depth: number;
+    readonly path: string;
+} | {
+    TAG: "FileWriteError";
+    readonly filePath: string;
+    readonly message: string;
+} | {
+    TAG: "InvalidConfigError";
+    readonly field: string;
+    readonly message: string;
+} | {
+    TAG: "UnknownError";
+    readonly message: string;
+    readonly context: (undefined | CodegenError_context);
+};
+export type Warning_t = {
+    TAG: "FallbackToJson";
+    readonly reason: string;
+    readonly context: CodegenError_context;
+} | {
+    TAG: "UnsupportedFeature";
+    readonly feature: string;
+    readonly fallback: string;
+    readonly location: string;
+} | {
+    TAG: "DepthLimitReached";
+    readonly depth: number;
+    readonly path: string;
+} | {
+    TAG: "MissingSchema";
+    readonly ref: string;
+    readonly location: string;
+} | {
+    TAG: "IntersectionNotFullySupported";
+    readonly location: string;
+    readonly note: string;
+} | {
+    TAG: "ComplexUnionSimplified";
+    readonly location: string;
+    readonly types: string;
+};

package/lib/es6/src/core/CodegenUtils.mjs

@@ -1,7 +1,7 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as Text from "@std/text";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as JsConvertCase from "js-convert-case";
 
 function sanitizeIdentifier(str) {
   return str.replaceAll("{", "").replaceAll("}", "").replaceAll("[", "").replaceAll("]", "").replaceAll(".", "_").replaceAll("-", "_").replaceAll("/", "_").replaceAll(" ", "_");
@@ -9,13 +9,13 @@ function sanitizeIdentifier(str) {
 
 function generateTypeName(prefixOpt, path, suffix) {
   let prefix = prefixOpt !== undefined ? prefixOpt : "";
-  let cleaned = sanitizeIdentifier(path.replaceAll("/", "_")).split("_").filter(part => part !== "").map(prim => Text.toPascalCase(prim)).join("");
+  let cleaned = sanitizeIdentifier(path.replaceAll("/", "_")).split("_").filter(part => part !== "").map(prim => JsConvertCase.toPascalCase(prim)).join("");
   return prefix + cleaned + suffix;
 }
 
 function generateOperationName(operationId, path, method) {
   if (operationId !== undefined) {
-    return Text.toCamelCase(sanitizeIdentifier(operationId));
+    return JsConvertCase.toCamelCase(sanitizeIdentifier(operationId));
   } else {
     return method.toLowerCase() + path.split("/").filter(part => {
       if (part !== "") {
@@ -23,7 +23,7 @@ function generateOperationName(operationId, path, method) {
       } else {
         return false;
       }
-    }).map(prim => Text.toCamelCase(prim)).join("");
+    }).map(prim => JsConvertCase.toCamelCase(prim)).join("");
   }
 }
 
@@ -183,4 +183,4 @@ export {
   generateDocString,
   fetchTypeSignature,
 }
-/* @std/text Not a pure module */
+/* js-convert-case Not a pure module */

package/lib/es6/src/core/DocOverride.mjs

@@ -1,13 +1,13 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Fs from "fs";
-import * as Text from "@std/text";
 import * as Js_string from "@rescript/runtime/lib/es6/Js_string.js";
 import * as FileSystem from "./FileSystem.mjs";
 import * as CodegenUtils from "./CodegenUtils.mjs";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as JsConvertCase from "js-convert-case";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
 function generateEndpointHash(endpoint) {
@@ -264,7 +264,7 @@ function generateOverrideFiles(spec, endpoints, outputDir, host, groupByTagOpt,
       moduleName = "API";
     }
     let functionName = CodegenUtils.generateOperationName(endpoint.operationId, endpoint.path, endpoint.method);
-    let modulePath = FileSystem.makePath(outputDir, Text.toPascalCase(moduleName));
+    let modulePath = FileSystem.makePath(outputDir, JsConvertCase.toPascalCase(moduleName));
     let filePath = FileSystem.makePath(modulePath, functionName + ".md");
     if (isFileCustomized(filePath)) {
       console.log(`ℹ️  Skipping ` + moduleName + `/` + functionName + ` - file already customized`);

package/lib/es6/src/core/FileSystem.d.ts

@@ -0,0 +1,4 @@
+export type fileToWrite = {
+    readonly path: string;
+    readonly content: string;
+};

package/lib/es6/src/core/FileSystem.mjs

@@ -1,14 +1,14 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Fs from "fs";
-import * as Path from "@std/path";
+import * as Pathe from "pathe";
 import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
 function ensureDir(path) {
   try {
-    Fs.mkdirSync(Path.dirname(path), {
+    Fs.mkdirSync(Pathe.dirname(path), {
       recursive: true
     });
     return;
@@ -66,7 +66,7 @@ function writeFiles(files) {
 }
 
 function makePath(baseDir, filename) {
-  return Path.join(baseDir, filename);
+  return Pathe.join(baseDir, filename);
 }
 
 export {

package/lib/es6/src/core/Pipeline.d.ts

@@ -0,0 +1,6 @@
+import type { fileToWrite as FileSystem_fileToWrite } from './FileSystem';
+import type { warning as Types_warning } from '../../src/Types';
+export type t = {
+    readonly files: FileSystem_fileToWrite[];
+    readonly warnings: Types_warning[];
+};

package/lib/es6/src/core/ReferenceResolver.mjs

@@ -1,6 +1,6 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as Text from "@std/text";
+import * as JsConvertCase from "js-convert-case";
 
 function refToTypePath(insideComponentSchemasOpt, modulePrefixOpt, ref) {
   let insideComponentSchemas = insideComponentSchemasOpt !== undefined ? insideComponentSchemasOpt : false;
@@ -10,7 +10,7 @@ function refToTypePath(insideComponentSchemasOpt, modulePrefixOpt, ref) {
   if (schemaName === undefined) {
     return;
   }
-  let moduleName = Text.toPascalCase(schemaName);
+  let moduleName = JsConvertCase.toPascalCase(schemaName);
   if (insideComponentSchemas) {
     return moduleName + `.t`;
   } else {
@@ -26,7 +26,7 @@ function refToSchemaPath(insideComponentSchemasOpt, modulePrefixOpt, ref) {
   if (schemaName === undefined) {
     return;
   }
-  let moduleName = Text.toPascalCase(schemaName);
+  let moduleName = JsConvertCase.toPascalCase(schemaName);
   if (insideComponentSchemas) {
     return moduleName + `.schema`;
   } else {
@@ -38,4 +38,4 @@ export {
   refToTypePath,
   refToSchemaPath,
 }
-/* @std/text Not a pure module */
+/* js-convert-case Not a pure module */

package/lib/es6/src/generators/ComponentSchemaGenerator.mjs

@@ -1,13 +1,13 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Pipeline from "../core/Pipeline.mjs";
-import * as Text from "@std/text";
 import * as FileSystem from "../core/FileSystem.mjs";
 import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
 import * as CodegenUtils from "../core/CodegenUtils.mjs";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as SchemaIRParser from "../core/SchemaIRParser.mjs";
+import * as JsConvertCase from "js-convert-case";
 import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
 import * as GenerationContext from "../types/GenerationContext.mjs";
 import * as IRToSuryGenerator from "./IRToSuryGenerator.mjs";
@@ -105,7 +105,7 @@ function generate(spec, outputDir) {
     warnings.push(...typeCtx.warnings);
     warnings.push(...schemaCtx.warnings);
     let docComment = Stdlib_Option.mapOr(schema.description, "", d => CodegenUtils.generateDocString(undefined, d, undefined));
-    return docComment + `module ` + Text.toPascalCase(schema.name) + ` = {
+    return docComment + `module ` + JsConvertCase.toPascalCase(schema.name) + ` = {
   type t = ` + typeCode + `
   let schema = ` + schemaCode + `
 }`;
@@ -122,4 +122,4 @@ export {
   extractReferencedSchemaNames,
   generate,
 }
-/* @std/text Not a pure module */
+/* FileSystem Not a pure module */

package/lib/es6/src/generators/EndpointGenerator.mjs

@@ -1,11 +1,11 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as Text from "@std/text";
 import * as DocOverride from "../core/DocOverride.mjs";
 import * as CodegenUtils from "../core/CodegenUtils.mjs";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as SchemaIRParser from "../core/SchemaIRParser.mjs";
+import * as JsConvertCase from "js-convert-case";
 import * as IRToSuryGenerator from "./IRToSuryGenerator.mjs";
 import * as IRToTypeGenerator from "./IRToTypeGenerator.mjs";
 
@@ -134,7 +134,7 @@ function generateEndpointModule(endpoint, modulePrefixOpt) {
   return CodegenUtils.trimMargin(`
     |` + header.trimEnd() + `
     |
-    |module ` + Text.toPascalCase(functionName) + ` = {
+    |module ` + JsConvertCase.toPascalCase(functionName) + ` = {
     |` + CodegenUtils.indent(generateEndpointCode(endpoint, undefined, undefined, modulePrefix), 2) + `
     |}
     |`, undefined);
@@ -169,4 +169,4 @@ export {
   generateEndpointsModule,
   generateEndpointSignature,
 }
-/* @std/text Not a pure module */
+/* DocOverride Not a pure module */

package/lib/es6/src/generators/IRToSuryGenerator.mjs

@@ -1,10 +1,10 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as SchemaIR from "../core/SchemaIR.mjs";
-import * as Text from "@std/text";
 import * as CodegenUtils from "../core/CodegenUtils.mjs";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as JsConvertCase from "js-convert-case";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
 import * as GenerationContext from "../types/GenerationContext.mjs";
@@ -72,7 +72,7 @@ function generateSchemaWithContext(ctx, depthOpt, irType) {
         let fields = properties.map(param => {
           let name = param[0];
           let schemaCode = recurse(param[1]);
-          let camelName = CodegenUtils.escapeKeyword(Text.toCamelCase(name));
+          let camelName = CodegenUtils.escapeKeyword(JsConvertCase.toCamelCase(name));
           if (param[2]) {
             return `    ` + camelName + `: s.field("` + name + `", ` + schemaCode + `),`;
           } else {
@@ -161,7 +161,7 @@ function generateSchemaWithContext(ctx, depthOpt, irType) {
         let schemaPath;
         if (available !== undefined) {
           let name = Stdlib_Option.getOr(ref.split("/")[ref.split("/").length - 1 | 0], "");
-          schemaPath = available.includes(name) ? Text.toPascalCase(name) + `.schema` : `ComponentSchemas.` + Text.toPascalCase(name) + `.schema`;
+          schemaPath = available.includes(name) ? JsConvertCase.toPascalCase(name) + `.schema` : `ComponentSchemas.` + JsConvertCase.toPascalCase(name) + `.schema`;
         } else {
           schemaPath = Stdlib_Option.getOr(ReferenceResolver.refToSchemaPath(ctx.insideComponentSchemas, ctx.modulePrefix, ref), "S.json");
         }
@@ -230,4 +230,4 @@ export {
   generateNamedSchema,
   generateAllSchemas,
 }
-/* @std/text Not a pure module */
+/* CodegenUtils Not a pure module */