@f3liz/rescript-autogen-openapi 0.1.0 → 0.1.6

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/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.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/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/core/SpecDiffer.mjs

@@ -150,9 +150,9 @@ function compareEndpointLists(baseEndpoints, forkEndpoints) {
   });
   let baseKeys = new Set(Object.keys(baseMap));
   let forkKeys = new Set(Object.keys(forkMap));
-  let added = Stdlib_Array.filterMap(Array.from(forkKeys.difference(baseKeys)), key => forkMap[key]);
-  let removed = Stdlib_Array.filterMap(Array.from(baseKeys.difference(forkKeys)), key => baseMap[key]);
-  let modified = Stdlib_Array.filterMap(Array.from(baseKeys.intersection(forkKeys)), key => {
+  let added = Stdlib_Array.filterMap(Array.from(forkKeys).filter(key => !baseKeys.has(key)), key => forkMap[key]);
+  let removed = Stdlib_Array.filterMap(Array.from(baseKeys).filter(key => !forkKeys.has(key)), key => baseMap[key]);
+  let modified = Stdlib_Array.filterMap(Array.from(baseKeys).filter(key => forkKeys.has(key)), key => {
     let match = baseMap[key];
     let match$1 = forkMap[key];
     if (match !== undefined && match$1 !== undefined) {
@@ -191,9 +191,9 @@ function compareComponentSchemas(baseSchemas, forkSchemas) {
   }
   let baseKeys = new Set(Object.keys(baseSchemas));
   let forkKeys = new Set(Object.keys(forkSchemas));
-  let added = Array.from(forkKeys.difference(baseKeys));
-  let removed = Array.from(baseKeys.difference(forkKeys));
-  let modified = Stdlib_Array.filterMap(Array.from(baseKeys.intersection(forkKeys)), name => {
+  let added = Array.from(forkKeys).filter(key => !baseKeys.has(key));
+  let removed = Array.from(baseKeys).filter(key => !forkKeys.has(key));
+  let modified = Stdlib_Array.filterMap(Array.from(baseKeys).filter(key => forkKeys.has(key)), name => {
     let match = baseSchemas[name];
     let match$1 = forkSchemas[name];
     if (match !== undefined && match$1 !== undefined && !schemasEqual(match, match$1)) {

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 */

package/lib/es6/src/generators/IRToTypeGenerator.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_string from "@rescript/runtime/lib/es6/Primitive_string.js";
 import * as GenerationContext from "../types/GenerationContext.mjs";
 import * as IRToSuryGenerator from "./IRToSuryGenerator.mjs";
@@ -54,7 +54,7 @@ function generateTypeWithContext(ctx, depthOpt, irType) {
           let name = param[0];
           let typeCode = recurse(param[1]);
           let finalType = param[2] ? typeCode : `option<` + typeCode + `>`;
-          let camelName = Text.toCamelCase(name);
+          let camelName = JsConvertCase.toCamelCase(name);
           let escapedName = CodegenUtils.escapeKeyword(camelName);
           let aliasAnnotation = escapedName !== name ? `@as("` + name + `") ` : "";
           return `  ` + aliasAnnotation + escapedName + `: ` + finalType + `,`;
@@ -128,7 +128,7 @@ function generateTypeWithContext(ctx, depthOpt, irType) {
             if (typeof s !== "object" || s.TAG !== "StringLiteral") {
               return "#Unknown";
             } else {
-              return `#` + Text.toPascalCase(s._0);
+              return `#` + JsConvertCase.toPascalCase(s._0);
             }
           }).join(" | ");
           return `[` + variants + `]`;
@@ -157,7 +157,7 @@ function generateTypeWithContext(ctx, depthOpt, irType) {
         let typePath;
         if (available !== undefined) {
           let name = Stdlib_Option.getOr(ref.split("/")[ref.split("/").length - 1 | 0], "");
-          typePath = available.includes(name) ? Text.toPascalCase(name) + `.t` : `ComponentSchemas.` + Text.toPascalCase(name) + `.t`;
+          typePath = available.includes(name) ? JsConvertCase.toPascalCase(name) + `.t` : `ComponentSchemas.` + JsConvertCase.toPascalCase(name) + `.t`;
         } else {
           typePath = Stdlib_Option.getOr(ReferenceResolver.refToTypePath(ctx.insideComponentSchemas, ctx.modulePrefix, ref), "JSON.t");
         }
@@ -238,4 +238,4 @@ export {
   generateAllTypes,
   generateTypeAndSchema,
 }
-/* @std/text Not a pure module */
+/* CodegenUtils Not a pure module */

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

@@ -1,8 +1,8 @@
 // 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 SchemaIRParser from "../core/SchemaIRParser.mjs";
+import * as JsConvertCase from "js-convert-case";
 
 function generateType(_irType, _isOptionalOpt) {
   while (true) {
@@ -129,7 +129,7 @@ function generateNamedType(namedSchema) {
 function generateParameterType(name, schema) {
   let match = SchemaIRParser.parseJsonSchema(undefined, schema);
   return [
-    Text.toCamelCase(name),
+    JsConvertCase.toCamelCase(name),
     generateType(match[0], undefined)
   ];
 }
@@ -140,4 +140,4 @@ export {
   generateNamedType,
   generateParameterType,
 }
-/* @std/text Not a pure module */
+/* js-convert-case Not a pure module */

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

@@ -1,7 +1,6 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 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 CodegenUtils from "../core/CodegenUtils.mjs";
@@ -9,6 +8,7 @@ import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as OpenAPIParser from "../core/OpenAPIParser.mjs";
 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_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
 import * as EndpointGenerator from "./EndpointGenerator.mjs";
@@ -45,7 +45,7 @@ function generateTagModulesCode(endpoints, overrideDir, indentOpt) {
   let groupedByTag = OpenAPIParser.groupByTag(endpoints);
   let indentStr = " ".repeat(indent);
   return Stdlib_Array.filterMap(Object.keys(groupedByTag).toSorted(Primitive_string.compare), tag => Stdlib_Option.map(groupedByTag[tag], tagEndpoints => {
-    let moduleName = Text.toPascalCase(tag);
+    let moduleName = JsConvertCase.toPascalCase(tag);
     let endpointLines = tagEndpoints.flatMap(endpoint => [
       CodegenUtils.indent(EndpointGenerator.generateEndpointCode(endpoint, overrideDir, moduleName, undefined), indent + 2 | 0),
       ""
@@ -62,7 +62,7 @@ function generateTagModuleFile(tag, endpoints, $staropt$star, $staropt$star$1, o
     true;
   }
   let wrapInModule = $staropt$star$1 !== undefined ? $staropt$star$1 : false;
-  let moduleName = Text.toPascalCase(tag);
+  let moduleName = JsConvertCase.toPascalCase(tag);
   let header = CodegenUtils.generateFileHeader(`API endpoints for ` + tag);
   let body = endpoints.map(endpoint => EndpointGenerator.generateEndpointCode(endpoint, overrideDir, moduleName, undefined)).join("\n\n");
   if (wrapInModule) {
@@ -99,7 +99,7 @@ function generateIndexModule(tags, moduleNameOpt) {
   let moduleName = moduleNameOpt !== undefined ? moduleNameOpt : "API";
   let header = CodegenUtils.generateFileHeader("Main API module index");
   let modules = tags.toSorted(Primitive_string.compare).map(tag => {
-    let m = Text.toPascalCase(tag);
+    let m = JsConvertCase.toPascalCase(tag);
     return `  module ` + m + ` = ` + m;
   }).join("\n");
   return CodegenUtils.trimMargin(`
@@ -162,7 +162,7 @@ function generateSharedModule(endpoints, schemas, overrideDir, includeHeaderOpt)
 
 function generateExtensionModule(forkName, endpoints, schemas, overrideDir, includeHeaderOpt) {
   let includeHeader = includeHeaderOpt !== undefined ? includeHeaderOpt : true;
-  return internalGenerateIntegratedModule(Text.toPascalCase(forkName) + `Extensions`, forkName + ` extensions`, endpoints, schemas, overrideDir, true, includeHeader);
+  return internalGenerateIntegratedModule(JsConvertCase.toPascalCase(forkName) + `Extensions`, forkName + ` extensions`, endpoints, schemas, overrideDir, true, includeHeader);
 }
 
 function generateCombinedModule(forkName, sharedEndpoints, extensionEndpoints, sharedSchemas, extensionSchemas, overrideDir) {
@@ -181,7 +181,7 @@ function generateCombinedModule(forkName, sharedEndpoints, extensionEndpoints, s
 function generateTagModuleFiles(endpoints, outputDir, wrapInModuleOpt, overrideDir) {
   let wrapInModule = wrapInModuleOpt !== undefined ? wrapInModuleOpt : false;
   let files = generateAllTagModules(endpoints, true, wrapInModule, overrideDir).map(param => {
-    let path = FileSystem.makePath(outputDir, Text.toPascalCase(param[0]) + `.res`);
+    let path = FileSystem.makePath(outputDir, JsConvertCase.toPascalCase(param[0]) + `.res`);
     return {
       path: path,
       content: param[1]
@@ -231,7 +231,7 @@ function generateInstanceTagModules(instanceName, modulePrefix, endpoints, schem
   let groupedByTag = OpenAPIParser.groupByTag(endpoints);
   let endpointFiles = Stdlib_Array.filterMap(Object.entries(groupedByTag).toSorted((param, param$1) => Primitive_string.compare(param[0], param$1[0])), param => {
     let tag = param[0];
-    let moduleName = modulePrefix + Text.toPascalCase(tag);
+    let moduleName = modulePrefix + JsConvertCase.toPascalCase(tag);
     let endpointCodes = param[1].flatMap(endpoint => [
       EndpointGenerator.generateEndpointCode(endpoint, overrideDir, moduleName, modulePrefix),
       ""
@@ -260,7 +260,7 @@ function generateSeparatePerTagModules(baseName, basePrefix, forkName, forkPrefi
   let forkPrefix = forkPrefixOpt !== undefined ? Primitive_option.valFromOption(forkPrefixOpt) : undefined;
   return Pipeline.combine([
     generateBaseTagModules(baseName, basePrefix, sharedEndpoints, sharedSchemas, outputDir, overrideDir),
-    generateForkTagModules(forkName, Stdlib_Option.getOr(forkPrefix, Text.toPascalCase(forkName)), extensionEndpoints, extensionSchemas, outputDir, overrideDir)
+    generateForkTagModules(forkName, Stdlib_Option.getOr(forkPrefix, JsConvertCase.toPascalCase(forkName)), extensionEndpoints, extensionSchemas, outputDir, overrideDir)
   ]);
 }
 
@@ -282,4 +282,4 @@ export {
   generateForkTagModules,
   generateSeparatePerTagModules,
 }
-/* @std/text Not a pure module */
+/* FileSystem Not a pure module */

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

@@ -1,10 +1,10 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as Text from "@std/text";
 import * as CodegenUtils from "../core/CodegenUtils.mjs";
 import * as OpenAPIParser from "../core/OpenAPIParser.mjs";
 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";
 
@@ -34,7 +34,7 @@ function generateComponentSchemas(components) {
 }
 
 function generateOperationSchemas(operationId, operation) {
-  let generatePart = (suffix, schemaOpt) => Stdlib_Option.mapOr(schemaOpt, "", schema => generateTypeCodeAndSchemaCode(Text.toPascalCase(operationId) + suffix, schema));
+  let generatePart = (suffix, schemaOpt) => Stdlib_Option.mapOr(schemaOpt, "", schema => generateTypeCodeAndSchemaCode(JsConvertCase.toPascalCase(operationId) + suffix, schema));
   let requestBodySchema = Stdlib_Option.flatMap(Stdlib_Option.flatMap(operation.requestBody, body => body.content["application/json"]), mediaType => mediaType.schema);
   let responses = operation.responses;
   let successResponseSchema = Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_Option.orElse(responses["200"], responses["201"]), response => response.content), content => content["application/json"]), mediaType => mediaType.schema);
@@ -59,7 +59,7 @@ function generateEndpointModule(path, method, operation) {
         )
     );
   let schemasCode = generateOperationSchemas(operationId, operation);
-  return docComment + `module ` + Text.toPascalCase(operationId) + ` = {
+  return docComment + `module ` + JsConvertCase.toPascalCase(operationId) + ` = {
 ` + CodegenUtils.indent(schemasCode, 2) + `
 
   let endpoint = "` + path + `"
@@ -74,4 +74,4 @@ export {
   generateOperationSchemas,
   generateEndpointModule,
 }
-/* @std/text Not a pure module */
+/* CodegenUtils Not a pure module */

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

@@ -1,12 +1,12 @@
 // 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 CodegenUtils from "../core/CodegenUtils.mjs";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as OpenAPIParser from "../core/OpenAPIParser.mjs";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as JsConvertCase from "js-convert-case";
 
 let clientTypeCode = CodegenUtils.trimMargin(`
   |type client = {
@@ -65,7 +65,7 @@ function generateWrapper(spec, endpoints, extensionEndpointsOpt, outputDir, wrap
   ).concat(extensionEndpoints);
   let endpointsByTag = OpenAPIParser.groupByTag(allEndpoints);
   let modulesCode = Object.keys(endpointsByTag).map(tag => {
-    let moduleName = Text.toPascalCase(tag);
+    let moduleName = JsConvertCase.toPascalCase(tag);
     let wrapperFunctions = Stdlib_Option.getOr(endpointsByTag[tag], []).map(endpoint => {
       let operationName = CodegenUtils.generateOperationName(endpoint.operationId, endpoint.path, endpoint.method);
       let isExtension = hasExtensions && operationName in extensionOperationIds;

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

@@ -1,12 +1,12 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as Text from "@std/text";
 import * as FileSystem from "../core/FileSystem.mjs";
 import * as CodegenUtils from "../core/CodegenUtils.mjs";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as OpenAPIParser from "../core/OpenAPIParser.mjs";
 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 IRToTypeScriptGenerator from "./IRToTypeScriptGenerator.mjs";
 
 function getFirstJsonSchema(contentDict) {
@@ -23,12 +23,12 @@ function generateTypeScriptType(name, description, schema) {
 }
 
 function generateRequestInterface(endpoint, functionName) {
-  let requestTypeName = Text.toPascalCase(functionName) + `Request`;
+  let requestTypeName = JsConvertCase.toPascalCase(functionName) + `Request`;
   return Stdlib_Option.flatMap(endpoint.requestBody, body => Stdlib_Option.map(getFirstJsonSchema(body.content), schema => generateTypeScriptType(requestTypeName, body.description, schema)));
 }
 
 function generateResponseInterface(endpoint, functionName) {
-  let responseTypeName = Text.toPascalCase(functionName) + `Response`;
+  let responseTypeName = JsConvertCase.toPascalCase(functionName) + `Response`;
   let successCodes = [
     "200",
     "201",
@@ -40,7 +40,7 @@ function generateResponseInterface(endpoint, functionName) {
 }
 
 function generateMethodSignature(endpoint, functionName) {
-  let params = Stdlib_Option.isSome(endpoint.requestBody) ? `client: MisskeyClient, request: ` + Text.toPascalCase(functionName) + `Request` : "client: MisskeyClient";
+  let params = Stdlib_Option.isSome(endpoint.requestBody) ? `client: MisskeyClient, request: ` + JsConvertCase.toPascalCase(functionName) + `Request` : "client: MisskeyClient";
   let docLines = Stdlib_Option.mapOr(endpoint.summary, [], summary => {
     let lines = [
       "  /**",
@@ -57,7 +57,7 @@ function generateMethodSignature(endpoint, functionName) {
   });
   let code = `
     |` + docLines.join("\n") + `
-    |  ` + functionName + `(` + params + `): Promise<` + Text.toPascalCase(functionName) + `Response>;`;
+    |  ` + functionName + `(` + params + `): Promise<` + JsConvertCase.toPascalCase(functionName) + `Response>;`;
   return CodegenUtils.trimMargin(code, undefined);
 }
 
@@ -135,7 +135,7 @@ function generate(spec, endpoints, outputDir) {
     if (tagEndpoints.length === 0) {
       return;
     }
-    let name = Text.toPascalCase(param[0]);
+    let name = JsConvertCase.toPascalCase(param[0]);
     moduleNames.push(name);
     return {
       path: FileSystem.makePath(outputDir, `types/` + name + `.d.ts`),
@@ -169,4 +169,4 @@ export {
   generateIndexDts,
   generate,
 }
-/* @std/text Not a pure module */
+/* FileSystem Not a pure module */

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

@@ -1,11 +1,11 @@
 // 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 CodegenUtils from "../core/CodegenUtils.mjs";
 import * as OpenAPIParser from "../core/OpenAPIParser.mjs";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as JsConvertCase from "js-convert-case";
 
 let misskeyClientJsCode = CodegenUtils.trimMargin(`
   |export class MisskeyClient {
@@ -32,11 +32,11 @@ function generateWrapperMjs(endpoints, generatedModulePath) {
   let endpointsByTag = OpenAPIParser.groupByTag(endpoints);
   let tags = Object.keys(endpointsByTag);
   let imports = tags.map(tag => {
-    let moduleName = Text.toPascalCase(tag);
+    let moduleName = JsConvertCase.toPascalCase(tag);
     return `import * as ` + moduleName + ` from '` + generatedModulePath + `/` + moduleName + `.mjs';`;
   }).join("\n");
   let wrappers = tags.map(tag => {
-    let moduleName = Text.toPascalCase(tag);
+    let moduleName = JsConvertCase.toPascalCase(tag);
     let methods = Stdlib_Option.getOr(endpointsByTag[tag], []).map(endpoint => {
       let functionName = CodegenUtils.generateOperationName(endpoint.operationId, endpoint.path, endpoint.method);
       let hasRequestBody = Stdlib_Option.isSome(endpoint.requestBody);
@@ -69,9 +69,9 @@ function generateWrapperDts(endpoints) {
   let endpointsByTag = OpenAPIParser.groupByTag(endpoints);
   let tags = Object.keys(endpointsByTag);
   let imports = tags.map(tag => {
-    let moduleName = Text.toPascalCase(tag);
+    let moduleName = JsConvertCase.toPascalCase(tag);
     let typesToImport = Stdlib_Option.getOr(endpointsByTag[tag], []).flatMap(endpoint => {
-      let pascalName = Text.toPascalCase(CodegenUtils.generateOperationName(endpoint.operationId, endpoint.path, endpoint.method));
+      let pascalName = JsConvertCase.toPascalCase(CodegenUtils.generateOperationName(endpoint.operationId, endpoint.path, endpoint.method));
       if (Stdlib_Option.isSome(endpoint.requestBody)) {
         return [
           `  ` + pascalName + `Request,`,
@@ -86,10 +86,10 @@ function generateWrapperDts(endpoints) {
 } from '../types/` + moduleName + `.d.ts';`;
   }).join("\n");
   let namespaces = tags.map(tag => {
-    let moduleName = Text.toPascalCase(tag);
+    let moduleName = JsConvertCase.toPascalCase(tag);
     let functions = Stdlib_Option.getOr(endpointsByTag[tag], []).map(endpoint => {
       let functionName = CodegenUtils.generateOperationName(endpoint.operationId, endpoint.path, endpoint.method);
-      let pascalName = Text.toPascalCase(functionName);
+      let pascalName = JsConvertCase.toPascalCase(functionName);
       let docComment = Stdlib_Option.mapOr(endpoint.summary, "", summary => {
         let descriptionPart = Stdlib_Option.mapOr(endpoint.description, "", description => {
           if (description === summary) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@f3liz/rescript-autogen-openapi",
-  "version": "0.1.0",
+  "version": "0.1.6",
   "description": "Generate ReScript code with Sury schemas from OpenAPI 3.1 specs. Supports multiple forks with diff/merge capabilities.",
   "keywords": [
     "rescript",
@@ -12,7 +12,7 @@
     "api",
     "generator"
   ],
-  "author": "",
+  "author": "NyanRus",
   "license": "MPL-2.0",
   "files": [
     "src/**/*.res",
@@ -21,6 +21,9 @@
     "README.md",
     "LICENSE"
   ],
+  "repository": {
+    "url": "https://github.com/f3liz-dev/rescript-autogen-openapi"
+  },
   "scripts": {
     "build": "rescript",
     "clean": "rescript clean",
@@ -31,8 +34,8 @@
   "type": "module",
   "dependencies": {
     "@readme/openapi-parser": "^5.5.0",
-    "@std/path": "npm:@jsr/std__path@^1.1.4",
-    "@std/text": "npm:@jsr/std__text@^1.0.17",
+    "js-convert-case": "^4.2.0",
+    "pathe": "^2.0.3",
     "sury": "11.0.0-alpha.4"
   },
   "devDependencies": {

package/src/core/CodegenUtils.res

@@ -3,10 +3,10 @@
 // CodegenUtils.res - Utility functions for code generation
 
 // Convert a string to PascalCase
-@module("@std/text") external toPascalCase: string => string = "toPascalCase"
+@module("js-convert-case") external toPascalCase: string => string = "toPascalCase"
 
 // Convert a string to camelCase
-@module("@std/text") external toCamelCase: string => string = "toCamelCase"
+@module("js-convert-case") external toCamelCase: string => string = "toCamelCase"
 
 // Sanitize identifier (remove special characters, ensure valid ReScript identifier)
 let sanitizeIdentifier = (str: string): string =>

package/src/core/FileSystem.res

@@ -4,8 +4,8 @@
 
 @module("fs") external mkdirSync: (string, {"recursive": bool}) => unit = "mkdirSync"
 @module("fs") external writeFileSync: (string, string, string) => unit = "writeFileSync"
-@module("@std/path") external join: (string, string) => string = "join"
-@module("@std/path") external dirname: string => string = "dirname"
+@module("pathe") external join: (string, string) => string = "join"
+@module("pathe") external dirname: string => string = "dirname"
 
 // Represents a file to be written
 type fileToWrite = {

package/src/core/SpecDiffer.res

@@ -151,20 +151,20 @@ let compareEndpointLists = (
 
   // Find added endpoints (in fork but not in base)
   let added = forkKeys
-    ->Set.difference(baseKeys)
     ->Set.toArray
+    ->Array.filter(key => !(baseKeys->Set.has(key)))
     ->Array.filterMap(key => Dict.get(forkMap, key))
 
   // Find removed endpoints (in base but not in fork)
   let removed = baseKeys
-    ->Set.difference(forkKeys)
     ->Set.toArray
+    ->Array.filter(key => !(forkKeys->Set.has(key)))
     ->Array.filterMap(key => Dict.get(baseMap, key))
 
   // Find modified endpoints (in both but different)
   let modified = baseKeys
-    ->Set.intersection(forkKeys)
     ->Set.toArray
+    ->Array.filter(key => forkKeys->Set.has(key))
     ->Array.filterMap(key => {
       switch (Dict.get(baseMap, key), Dict.get(forkMap, key)) {
       | (Some(baseEp), Some(forkEp)) => compareEndpoints(baseEp, forkEp)
@@ -190,18 +190,18 @@ let compareComponentSchemas = (
 
       // Added schemas
       let added = forkKeys
-        ->Set.difference(baseKeys)
         ->Set.toArray
+        ->Array.filter(key => !(baseKeys->Set.has(key)))
 
       // Removed schemas
       let removed = baseKeys
-        ->Set.difference(forkKeys)
         ->Set.toArray
+        ->Array.filter(key => !(forkKeys->Set.has(key)))
 
       // Modified schemas
       let modified = baseKeys
-        ->Set.intersection(forkKeys)
         ->Set.toArray
+        ->Array.filter(key => forkKeys->Set.has(key))
         ->Array.filterMap(name => {
           switch (Dict.get(base, name), Dict.get(fork, name)) {
           | (Some(baseSchema), Some(forkSchema)) =>