arri 0.0.5 → 0.0.6

package/dist/{codegen/index.mjs → shared/arri.34695f7b.mjs}

@@ -1,16 +1,14 @@
-import { u as unflattenObject, p as pascalCase, i as isProcedureDefinition, a as isJsonSchemaScalarType, b as isJsonSchemaNullType, c as isJsonSchemaObject, d as isJsonSchemaEnum, e as isJsonSchemaArray, f as camelCase } from '../shared/arri.215ad025.mjs';
 import { createRequire, builtinModules } from 'module';
 import { fileURLToPath, pathToFileURL, URL } from 'url';
-import path6, { dirname } from 'path';
+import require$$0, { dirname } from 'path';
 import process4 from 'process';
-import os from 'os';
+import require$$0$1 from 'os';
 import tty from 'tty';
-import fs$1, { realpathSync, statSync, Stats, writeFileSync } from 'fs';
+import fs$1, { realpathSync, statSync, Stats } from 'fs';
 import assert4 from 'assert';
 import fs from 'fs/promises';
 import v8 from 'v8';
 import { format, inspect } from 'util';
-import { execSync } from 'child_process';
 
 const require$1 = createRequire(import.meta.url);
 const __filename$1 = fileURLToPath(import.meta.url);
@@ -21403,7 +21401,7 @@ function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
     return min;
   }
   if (process4.platform === "win32") {
-    const osRelease = os.release().split(".");
+    const osRelease = require$$0$1.release().split(".");
     if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
       return Number(osRelease[2]) >= 14931 ? 3 : 2;
     }
@@ -25999,10 +25997,10 @@ var partition_default = partition2;
 var import_editorconfig = __toESM(require_src(), 1);
 var import_editorconfig_to_prettier = __toESM(require_editorconfig_to_prettier(), 1);
 var MARKERS = [".git", ".hg"];
-var markerExists = (directory) => MARKERS.some((mark) => fs$1.existsSync(path6.join(directory, mark)));
+var markerExists = (directory) => MARKERS.some((mark) => fs$1.existsSync(require$$0.join(directory, mark)));
 function findProjectRoot(directory) {
   while (!markerExists(directory)) {
-    const parentDirectory = path6.resolve(directory, "..");
+    const parentDirectory = require$$0.resolve(directory, "..");
     if (parentDirectory === directory) {
       break;
     }
@@ -26015,7 +26013,7 @@ var find_project_root_default = findProjectRoot;
 // src/config/resolve-editorconfig.js
 async function loadEditorConfig(filePath) {
   const editorConfig = await import_editorconfig.default.parse(filePath, {
-    root: find_project_root_default(path6.dirname(path6.resolve(filePath)))
+    root: find_project_root_default(require$$0.dirname(require$$0.resolve(filePath)))
   });
   const config = (0, import_editorconfig_to_prettier.default)(editorConfig);
   if (config) {
@@ -26392,7 +26390,7 @@ var package_json_reader_default = reader;
 function read(jsonPath) {
   try {
     const string = fs$1.readFileSync(
-      path6.toNamespacedPath(path6.join(path6.dirname(jsonPath), "package.json")),
+      require$$0.toNamespacedPath(require$$0.join(require$$0.dirname(jsonPath), "package.json")),
       "utf8"
     );
     return { string };
@@ -26735,7 +26733,7 @@ function finalizeResolution(resolved, base, preserveSymlinks) {
   if (!preserveSymlinks) {
     const real = realpathSync(filePath);
     const { search, hash } = resolved;
-    resolved = pathToFileURL(real + (filePath.endsWith(path6.sep) ? "/" : ""));
+    resolved = pathToFileURL(real + (filePath.endsWith(require$$0.sep) ? "/" : ""));
     resolved.search = search;
     resolved.hash = hash;
   }
@@ -27534,7 +27532,7 @@ async function resolveConfig(filePath, options8) {
   };
   if (Array.isArray(merged.plugins)) {
     merged.plugins = merged.plugins.map(
-      (value) => typeof value === "string" && value.startsWith(".") ? path6.resolve(path6.dirname(result.filepath), value) : value
+      (value) => typeof value === "string" && value.startsWith(".") ? require$$0.resolve(require$$0.dirname(result.filepath), value) : value
     );
   }
   return merged;
@@ -27548,7 +27546,7 @@ function mergeOverrides(configResult, filePath) {
   const { config, filepath: configPath } = configResult || {};
   const { overrides, ...options8 } = config || {};
   if (filePath && overrides) {
-    const relativeFilePath = path6.relative(path6.dirname(configPath), filePath);
+    const relativeFilePath = require$$0.relative(require$$0.dirname(configPath), filePath);
     for (const override of overrides) {
       if (pathMatchesGlobs(
         relativeFilePath,
@@ -27594,7 +27592,7 @@ var read_file_default = readFile;
 
 // src/utils/ignore.js
 var createIgnore = import_ignore.default.default;
-var slash = path6.sep === "\\" ? (filepath) => string_replace_all_default(
+var slash = require$$0.sep === "\\" ? (filepath) => string_replace_all_default(
   /* isOptionalObject*/
   false,
   filepath,
@@ -27616,8 +27614,8 @@ async function createSingleIsIgnoredFunction(ignoreFilePath, withNodeModules) {
     allowRelativePaths: true
   }).add(content);
   return (filepath) => {
-    filepath = path6.resolve(filepath);
-    const relativePath = ignoreFilePath ? path6.relative(path6.dirname(ignoreFilePath), filepath) : path6.relative(process.cwd(), filepath);
+    filepath = require$$0.resolve(filepath);
+    const relativePath = ignoreFilePath ? require$$0.relative(require$$0.dirname(ignoreFilePath), filepath) : require$$0.relative(process.cwd(), filepath);
     return ignore.ignores(slash(relativePath));
   };
 }
@@ -27667,7 +27665,7 @@ async function getParser(filePath, options8) {
 }
 var get_file_info_default = getFileInfo;
 function importFromDirectory(specifier, directory) {
-  return import_from_file_default(specifier, path6.join(directory, "noop.js"));
+  return import_from_file_default(specifier, require$$0.join(directory, "noop.js"));
 }
 var import_from_directory_default = importFromDirectory;
 
@@ -27682,7 +27680,7 @@ var loadPluginFromDirectory = mem(
 );
 var importPlugin = mem(async (name) => {
   try {
-    return await import(pathToFileURL(path6.resolve(name)).href);
+    return await import(pathToFileURL(require$$0.resolve(name)).href);
   } catch {
     return import_from_directory_default(name, process.cwd());
   }
@@ -29029,809 +29027,4 @@ var debugApis = {
   printDocToString: withPlugins(printDocToString2)
 };
 
-function defineClientGeneratorPlugin(plugin) {
-  return plugin;
-}
-
-let createdModels = [];
-const typescriptClientGenerator = defineClientGeneratorPlugin(
-  (options) => ({
-    generator: async (def) => {
-      if (!options.name) {
-        throw new Error("Name is requires");
-      }
-      if (!options.outputFile) {
-        throw new Error("No output file specified");
-      }
-      const result = await createTypescriptClient(def, options.name);
-      writeFileSync(options.outputFile, result);
-    },
-    options
-  })
-);
-async function createTypescriptClient(def, prefix = "Client") {
-  createdModels = [];
-  const services = unflattenObject(def.procedures);
-  const serviceParts = [];
-  const modelParts = [];
-  Object.keys(services).forEach((key) => {
-    const serviceName = pascalCase(`${prefix}_${key}_service`);
-    serviceParts.push({
-      name: serviceName,
-      key,
-      content: tsServiceFromServiceDefinition(serviceName, services[key])
-    });
-  });
-  Object.keys(def.models).forEach((key) => {
-    const modelName = pascalCase(`${key}`);
-    if (!createdModels.includes(modelName)) {
-      modelParts.push(tsModelFromDefinition(modelName, def.models[key]));
-      createdModels.push(modelName);
-    }
-  });
-  return format2(
-    `/* eslint-disable */
-    import { arriRequest, ArriRequestError } from 'arri-client';
-    
-    export class ${prefix} {
-        ${serviceParts.map((service) => `${service.key}: ${service.name}`).join("\n")}
-        constructor(opts: { baseUrl?: string; headers?: Record<string, string> }) {
-            ${serviceParts.map(
-      (service) => `this.${service.key} = new ${service.name}(opts);`
-    ).join("\n")}
-        }
-    }
-
-    ${serviceParts.map((service) => service.content).join("\n")}
-    ${modelParts.join("\n")}`,
-    {
-      parser: "typescript"
-    }
-  );
-}
-function tsServiceFromServiceDefinition(name, def) {
-  const rpcParts = [];
-  const subServiceParts = [];
-  Object.keys(def).forEach((key) => {
-    const val = def[key];
-    if (isProcedureDefinition(val)) {
-      rpcParts.push(tsRpcFromProcedureDefinition(key, val));
-      return;
-    }
-    const subServiceName = pascalCase(
-      `${name.split("Service").join("")}_${key}_service`
-    );
-    subServiceParts.push({
-      name: subServiceName,
-      key,
-      content: tsServiceFromServiceDefinition(subServiceName, val)
-    });
-  });
-  return `export class ${name} {
-        baseUrl: string;
-        headers: Record<string, string>;
-        ${subServiceParts.map((service) => `${service.key}: ${service.name};`).join("\n")}
-        constructor(opts: { baseUrl?: string; headers?: Record<string, string> }) {
-            this.baseUrl = opts.baseUrl ?? "";
-            this.headers = opts.headers ?? {};
-            ${subServiceParts.map(
-    (service) => `this.${service.key} = new ${service.name}(opts);`
-  ).join("\n")}
-        }
-        ${rpcParts.join("\n")}
-    }
-    ${subServiceParts.map((service) => service.content).join("\n")}`;
-}
-function tsRpcFromProcedureDefinition(name, def) {
-  let paramStr = "";
-  let responseName = "";
-  if (def.params) {
-    paramStr = `params: ${def.params}`;
-  }
-  if (def.response) {
-    responseName = def.response;
-  }
-  return `async ${name}(${paramStr}) {
-        return arriRequest<${responseName || "undefined"}>({
-            url: \`\${this.baseUrl}${def.path}\`,
-            method: '${def.method}',
-            ${paramStr.length ? `params,` : ""}
-            headers: this.headers,
-        });
-    }`;
-}
-function tsModelFromDefinition(name, def) {
-  const fieldParts = [];
-  const subModelParts = [];
-  Object.keys(def.properties ?? {}).forEach((key) => {
-    const isOptional = !def.required?.includes(key);
-    const prop = def.properties?.[key];
-    const keyPart = isOptional ? `${key}?` : key;
-    if (isJsonSchemaScalarType(prop)) {
-      fieldParts.push(
-        tsInterfaceScalarField(key, prop, isOptional) ?? ""
-      );
-      return;
-    }
-    if (isJsonSchemaNullType(prop)) {
-      switch (prop.type) {
-        case "null":
-          fieldParts.push(`${keyPart}: null;`);
-          break;
-        case "undefined":
-          fieldParts.push(`${keyPart}: undefined`);
-          break;
-      }
-      return;
-    }
-    if (isJsonSchemaObject(prop)) {
-      const subModelName = prop.$id ?? pascalCase(`${name}_${key}`);
-      if (!createdModels.includes(subModelName)) {
-        const content = tsModelFromDefinition(
-          subModelName,
-          prop
-        );
-        subModelParts.push(content);
-      }
-      fieldParts.push(`${keyPart}: ${subModelName};`);
-      return;
-    }
-    if (isJsonSchemaEnum(prop)) {
-      const vals = prop.anyOf.map(
-        (opt) => opt.type === "string" ? `'${opt.const}'` : `${opt.const}`
-      );
-      fieldParts.push(`${keyPart}: ${vals.join(" | ")};`);
-      return;
-    }
-    if (isJsonSchemaArray(prop)) {
-      if (isJsonSchemaScalarType(prop.items)) {
-        const part = tsInterfaceScalarField(
-          key,
-          prop.items,
-          isOptional
-        ).replace(";", "[];");
-        fieldParts.push(part);
-        return;
-      }
-      if (isJsonSchemaNullType(prop.items)) {
-        if (prop.items.type === "null") {
-          fieldParts.push(`${keyPart}: null[]`);
-          return;
-        }
-        fieldParts.push(`${keyPart}: undefined[]`);
-        return;
-      }
-      if (isJsonSchemaObject(prop.items)) {
-        const subModelName = prop.items.$id ?? pascalCase(`${name}_${key}_item`);
-        if (!createdModels.includes(subModelName)) {
-          subModelParts.push(
-            tsModelFromDefinition(subModelName, prop.items)
-          );
-        }
-        fieldParts.push(`${keyPart}: ${subModelName}[];`);
-      }
-    }
-  });
-  return `export interface ${name} {
-        ${fieldParts.join("\n")}
-    }
-    ${subModelParts.join("\n")}`;
-}
-function tsInterfaceScalarField(key, prop, isOptional = false) {
-  const keyPart = isOptional ? `${key}?` : key;
-  switch (prop.type) {
-    case "string":
-      return `${keyPart}: string;`;
-    case "bigint":
-      return `${keyPart}: bigint;`;
-    case "Date":
-      return `${keyPart}: Date;`;
-    case "boolean":
-      return `${keyPart}: boolean;`;
-    case "integer":
-      return `/**
-                    * must be an integer
-                    */
-                    ${keyPart}: number;`;
-    case "number":
-      return `${keyPart}: number;`;
-  }
-}
-
-const dartClientGenerator = defineClientGeneratorPlugin(
-  (options) => {
-    return {
-      generator: async (def) => {
-        if (!options.clientName) {
-          throw new Error(
-            'Missing "clientName" cannot generate dart client'
-          );
-        }
-        if (!options.outputFile) {
-          throw new Error(
-            'Missing "outputFile" cannot generate dart client'
-          );
-        }
-        const result = createDartClient(def, options.clientName);
-        writeFileSync(options.outputFile, result);
-        execSync(`dart format ${options.outputFile}`);
-      },
-      options
-    };
-  }
-);
-const generatedModels = [];
-function createDartClient(appDef, prefix = "Client") {
-  const { models, procedures } = appDef;
-  const serviceParts = [];
-  const services = unflattenObject(procedures);
-  Object.keys(services).forEach((k) => {
-    const service = services[k];
-    const serviceName = pascalCase(`$_${prefix}_${k}_service`);
-    serviceParts.push({
-      name: serviceName,
-      key: k,
-      content: dartServiceFromServiceDefinition(
-        // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-        serviceName,
-        service,
-        prefix
-      )
-    });
-  });
-  const endpoints = {};
-  Object.keys(procedures).forEach((key) => {
-    const rpc = procedures[key];
-    endpoints[rpc.path] = rpc.method;
-  });
-  const modelParts = [];
-  Object.keys(models).forEach((key) => {
-    const model = models[key];
-    const typeName = `${prefix}${pascalCase(key)}`;
-    const objModel = model;
-    if (!generatedModels.includes(typeName)) {
-      modelParts.push(
-        dartModelFromJsonSchema(
-          `${prefix}${pascalCase(key)}`,
-          objModel
-        )
-      );
-      generatedModels.push(typeName);
-    }
-  });
-  return `// This code was autogenerated by arri. Do not modify directly.
-import "dart:convert";
-import "package:http/http.dart" as http;
-import "package:arri_client/arri_client.dart";
-
-class ${prefix} {
-  final String baseUrl;
-  final Map<String, String> headers;
-  const ${prefix}({
-    this.baseUrl = "",
-    this.headers = const {},
-  });
-  ${prefix} withHeaders(Map<String, String> headers) {
-    return ${prefix}(
-      baseUrl: baseUrl,
-      headers: headers,
-    );
-  }
-  ${serviceParts.map(
-    (service) => `${service.name} get ${service.key} {
-    return ${service.name}(
-      baseUrl: baseUrl, headers: headers,
-    );
-  }`
-  ).join("\n  ")}
-  Future<http.Response> rawRequest(
-    ${prefix}Endpoints endpoint, {
-    Map<String, String>? query,
-    dynamic body,
-    Map<String, String>? headers,
-    Encoding? encoding,
-  }) async {
-    return arriRequest(
-      "$baseUrl\${endpoint.path}",
-      method: endpoint.method,
-      headers: headers ?? this.headers,
-      body: body,
-      query: query,
-      encoding: encoding,
-    );
-  }
-}
-${serviceParts.map((item) => item.content).join("\n")}
-${modelParts.join("\n")}
-
-enum ${prefix}Endpoints implements Comparable<${prefix}Endpoints>, ArriEndpoint {
-  ${Object.keys(endpoints).map(
-    (key) => `${camelCase(key.split("/").join("_"))}(
-        path: "${key}",
-        method: HttpMethod.${endpoints[key]},
-      )`
-  ).join(",\n  ")};
-
-  const ${prefix}Endpoints({
-    required this.path, required this.method,
-  });
-  @override
-  final String path;
-  @override
-  final HttpMethod method;
-
-  @override
-  compareTo(BackendEndpoints other) => name.compareTo(other.name);
-}`;
-}
-function dartServiceFromServiceDefinition(name, def, prefix = "") {
-  const rpcParts = [];
-  const subServiceParts = [];
-  const serviceName = `${name}`;
-  Object.keys(def).forEach((key) => {
-    const item = def[key];
-    if (isProcedureDefinition(item)) {
-      let returnType = `Future<String>`;
-      let returnTypeName = "String";
-      if (item.response) {
-        returnType = `Future<${prefix}${item.response}>`;
-        returnTypeName = `${prefix}${item.response}`;
-      } else {
-        returnType = "Future<void>";
-      }
-      let paramsInput = "";
-      if (item.params) {
-        paramsInput = `${prefix}${item.params} params`;
-      }
-      let responseParser = "(body) => body;";
-      switch (returnType) {
-        case "Future<String>":
-          break;
-        case "Future<int>":
-          responseParser = `(body) => Int.parse(body)`;
-          break;
-        case "Future<double>":
-          responseParser = `(body) => Double.parse(body)`;
-          break;
-        case "Future<void>":
-          responseParser = `(body) {}`;
-          break;
-        case "Future<bool>":
-          responseParser = `(body) {
-                        switch(body) {
-                            case "true":
-                            case "1":
-                                return true;
-                            case "false":
-                            case "0":
-                            default:
-                                return false;
-                        }
-                    }`;
-          break;
-        default:
-          responseParser = `(body) => ${returnTypeName}.fromJson(json.decode(body))`;
-          break;
-      }
-      rpcParts.push(`${returnType} ${key}(${paramsInput}) {
-    return parsedArriRequest(
-      "$baseUrl${item.path}",
-      method: HttpMethod.${item.method},
-      headers: headers,
-      params: ${paramsInput.length ? `params.toJson()` : "null"},
-      parser: ${responseParser},
-    );
-  }`);
-      return;
-    }
-    const subServiceName = pascalCase(`${name}_${key}_Service`);
-    const subService = dartServiceFromServiceDefinition(
-      pascalCase(`${name}_${key}_Service`),
-      item,
-      prefix
-    );
-    subServiceParts.push({
-      name: subServiceName,
-      key,
-      content: subService
-    });
-  });
-  return `class ${serviceName} {
-  final String baseUrl;
-  final Map<String, String> headers;
-  const ${serviceName}({
-    this.baseUrl = "",
-    this.headers = const {},
-  });
-  ${subServiceParts.map(
-    (sub) => `${sub.name} get ${sub.key} {
-    return ${sub.name}(
-        baseUrl: baseUrl,
-        headers: headers,
-    );
-  }`
-  ).join("\n")}
-  ${rpcParts.join("\n  ")}
-}
-${subServiceParts.map((sub) => sub.content).join("\n")}
-`;
-}
-function dartModelFromJsonSchema(name, schema) {
-  const fields = [];
-  const subModelParts = [];
-  Object.entries(schema.properties ?? {}).forEach(([key, val]) => {
-    if (typeof val !== "object") {
-      return;
-    }
-    const [dartType, subTypes] = dartPropertyTypeFromSchema(
-      name,
-      key,
-      schema
-    );
-    if (subTypes?.length) {
-      for (const sub of subTypes) {
-        subModelParts.push(sub);
-      }
-    }
-    fields.push({ type: dartType, name: key });
-    if (!isDartType(dartType) && "type" in val && val.type === "object") {
-      subModelParts.push(
-        dartModelFromJsonSchema(dartType.replace("?", ""), val)
-      );
-    }
-  });
-  return `class ${name} {
-  ${fields.map((field) => `final ${field.type} ${field.name};`).join("\n  ")}
-  const ${name}({
-    ${fields.map(
-    (field) => field.type.includes("?") ? `this.${field.name},` : `required this.${field.name},`
-  ).join("\n    ")}
-  });
-  factory ${name}.fromJson(Map<String, dynamic> json) {
-    return ${name}(
-      ${fields.map((field) => `${dartParsedJsonField(field.name, field.type)},`).join("\n      ")}
-    );
-  }
-  Map<String, dynamic> toJson() {
-    return {
-      ${fields.map((field) => {
-    const isNullable = field.type.endsWith("?");
-    const typeName = field.type.replace("?", "");
-    if (isDartTypeWithNullables(field.type)) {
-      const transformer = transformers[typeName];
-      return transformer.toJsonBody(field.name, isNullable);
-    }
-    if (field.type.includes("List<")) {
-      return classListTransformer(typeName).toJsonBody(
-        field.name,
-        isNullable
-      );
-    }
-    return classTransformer(typeName, isNullable).toJsonBody(
-      field.name,
-      isNullable
-    );
-  }).join(",\n      ")},
-    };
-  }
-  ${name} copyWith({
-    ${fields.map((field) => `${field.type.replace("?", "")}? ${field.name},`).join("\n    ")}
-  }) {
-    return ${name}(
-      ${fields.map((field) => `${field.name}: ${field.name} ?? this.${field.name},`).join("\n      ")}
-    );
-  }
-}
-
-${subModelParts.join("\n")}`;
-}
-function dartPropertyTypeFromSchema(objectName, propertyName, schema) {
-  const prop = schema.properties?.[propertyName];
-  const isOptional = !schema.required?.includes(propertyName);
-  let finalType = "";
-  const subTypes = [];
-  if (isJsonSchemaEnum(prop)) {
-    const enumName = pascalCase(`${objectName}_${propertyName}`);
-    finalType = isOptional ? `${enumName}?` : enumName;
-    const options = [];
-    for (const opt of prop.anyOf) {
-      if (opt.type === "string") {
-        options.push({
-          name: opt.const.toString(),
-          type: "String",
-          value: opt.const
-        });
-      }
-      if (opt.type === "number" || opt.type === "integer") {
-        options.push({
-          name: camelCase(
-            `num_${opt.const}`.split(".").join("Point")
-          ),
-          type: opt.type === "number" ? "double" : "int",
-          value: opt.const
-        });
-      }
-    }
-    subTypes.push(`enum ${enumName} implements Comparable<${enumName}> {
-  ${options.map(
-      (opt) => `${opt.name}(${opt.type === "String" ? `"${opt.value}"` : opt.value})`
-    ).join(",\n  ")};
-  const ${enumName}(this.value);
-  final dynamic value;
-
-  @override
-  compareTo(${enumName} other) => name.compareTo(other.name);
-
-  factory ${enumName}.fromJson(dynamic input) {
-    for(final val in values) {
-      if(val.value == input) {
-        return val;
-      }
-    }
-    return ${options[0].name};
-  }
-
-  dynamic toJson() {
-    return value;
-  }
-}`);
-    return [finalType, subTypes];
-  }
-  if (isJsonSchemaNullType(prop)) {
-    finalType = "null";
-    return [finalType, subTypes];
-  }
-  if (isJsonSchemaScalarType(prop)) {
-    switch (prop.type) {
-      case "string":
-        finalType = isOptional ? "String?" : "String";
-        break;
-      case "integer":
-        finalType = isOptional ? "int?" : "int";
-        break;
-      case "number":
-        finalType = isOptional ? "double?" : "double";
-        break;
-      case "Date":
-        finalType = isOptional ? "DateTime?" : "DateTime";
-        break;
-      case "boolean":
-        finalType = isOptional ? "bool?" : "bool";
-        break;
-    }
-  }
-  if (isJsonSchemaObject(prop)) {
-    const joinedPropName = pascalCase(
-      `${objectName}_${propertyName}`
-    );
-    finalType = isOptional ? `${joinedPropName}?` : joinedPropName;
-  }
-  if (isJsonSchemaArray(prop)) {
-    const item = prop.items;
-    const type = item.type;
-    if (typeof type !== "string") {
-      throw new Error(
-        "Union types are not supported in arrays at this time"
-      );
-    }
-    switch (type) {
-      case "string":
-        finalType = isOptional ? "List<String>?" : "List<String>";
-        break;
-      case "integer":
-        finalType = isOptional ? "List<int>?" : "List<int>";
-        break;
-      case "number":
-        finalType = isOptional ? "List<double>?" : "List<double>";
-        break;
-      case "null":
-        finalType = isOptional ? "List<null>?" : "List<null>";
-        break;
-      case "boolean":
-        finalType = isOptional ? "List<bool>?" : "List<bool>";
-        break;
-      case "Date":
-        finalType = isOptional ? "List<DateTime>?" : "List<DateTime>";
-        break;
-      case "object": {
-        const subTypeName = item.$id ?? pascalCase(`${objectName}_${propertyName}_item`);
-        const model = dartModelFromJsonSchema(subTypeName, item);
-        if (!generatedModels.includes(subTypeName)) {
-          subTypes.push(model);
-          generatedModels.push(subTypeName);
-        }
-        finalType = isOptional ? `List<${subTypeName}>?` : `List<${subTypeName}>`;
-        break;
-      }
-    }
-  }
-  return [finalType, subTypes.length ? subTypes : void 0];
-}
-function dartParsedJsonField(fieldName, dartType) {
-  if (isDartTypeWithNullables(dartType)) {
-    switch (dartType) {
-      case "String":
-        return transformers.String.fromJsonBody(fieldName, '""');
-      case "String?":
-        return transformers.String.fromJsonBody(fieldName, "null");
-      case "bool":
-        return transformers.bool.fromJsonBody(fieldName, "false");
-      case "double":
-        return transformers.double.fromJsonBody(fieldName, "0.0");
-      case "int":
-        return transformers.int.fromJsonBody(fieldName, "0");
-      case "null":
-        return transformers.null.fromJsonBody(fieldName, "");
-      case "DateTime":
-        return transformers.DateTime.fromJsonBody(
-          fieldName,
-          "DateTime(0)"
-        );
-      case "DateTime?":
-        return transformers.DateTime.fromJsonBody(fieldName, "null");
-      case "List<String>":
-      case "List<bool>":
-      case "List<double>":
-      case "List<int>":
-      case "List<null>":
-        return defaultListFromJsonBody(
-          fieldName,
-          dartType.replace("List<", "").replace(">", ""),
-          "[]"
-        );
-      default:
-        return `${fieldName}: json["${fieldName}"] is ${dartType.replace(
-          "?",
-          ""
-        )} ? json["${fieldName}"] : null`;
-    }
-  }
-  if (dartType.includes("List<")) {
-    const innerType = dartType.replace("List<", "").replace(">", "").replace("?", "");
-    return classListTransformer(innerType).fromJsonBody(
-      fieldName,
-      dartType.endsWith("?") ? "null" : "[]"
-    );
-  }
-  const classType = dartType.split("?").join("").trim();
-  return classTransformer(classType, dartType.endsWith("?")).fromJsonBody(
-    fieldName,
-    classType
-  );
-}
-const dartTypeMap = {
-  integer: "int",
-  bigint: "int",
-  number: "double",
-  string: "String",
-  boolean: "bool",
-  null: "null",
-  Date: "DateTime",
-  object: void 0,
-  list: void 0,
-  // eslint-disable-next-line object-shorthand
-  undefined: void 0,
-  array: void 0,
-  Uint8Array: "Uint8List"
-};
-const transformers = {
-  null: {
-    fromJsonBody: (_) => `null`,
-    toJsonBody: defaultToJsonBody
-  },
-  int: {
-    fromJsonBody: (key, fallback) => defaultFromJsonBody(key, "int", fallback),
-    toJsonBody: defaultToJsonBody
-  },
-  double: {
-    fromJsonBody: (key, fallback) => defaultFromJsonBody(key, "double", fallback),
-    toJsonBody: defaultToJsonBody
-  },
-  String: {
-    fromJsonBody: (key, fallback) => defaultFromJsonBody(key, "String", fallback),
-    toJsonBody: defaultToJsonBody
-  },
-  bool: {
-    fromJsonBody: (key, fallback) => defaultFromJsonBody(key, "bool", fallback),
-    toJsonBody: defaultToJsonBody
-  },
-  DateTime: {
-    fromJsonBody: (key, fallback) => `${key}: json["${key}"] is String ? DateTime.parse(json["${key}"]) : ${fallback}`,
-    toJsonBody: (key, isNullable) => `"${key}": ${key}${isNullable ? "?" : ""}.toIso8601String()`
-  },
-  "List<null>": {
-    fromJsonBody: (key, fallback) => defaultListFromJsonBody(key, "null", fallback),
-    toJsonBody: defaultToJsonBody
-  },
-  "List<int>": {
-    fromJsonBody: (key, fallback) => defaultListFromJsonBody(key, "int", fallback),
-    toJsonBody: defaultToJsonBody
-  },
-  "List<double>": {
-    fromJsonBody: (key, fallback) => defaultListFromJsonBody(key, "double", fallback),
-    toJsonBody: defaultToJsonBody
-  },
-  "List<String>": {
-    fromJsonBody: (key, fallback) => defaultListFromJsonBody(key, "String", fallback),
-    toJsonBody: defaultToJsonBody
-  },
-  "List<bool>": {
-    fromJsonBody: (key, fallback) => defaultListFromJsonBody(key, "bool", fallback),
-    toJsonBody: defaultToJsonBody
-  },
-  "List<DateTime>": {
-    fromJsonBody: (key, fallback) => `${key}: json["${key}"] is List<String> ?
-            (json["${key}"] as List<String>)
-                .map((item) => DateTime.parse(item)).toList() : ${fallback}`,
-    toJsonBody: (key, isNullable) => `"${key}": ${key}${isNullable ? "?" : ""}.map((val) => val.toIso8601String()).toList()`
-  },
-  Uint8List: {
-    fromJsonBody: (key, fallback) => `${key}: json["${key}"] is List ? Uint8List.fromList(json["${key}"]) : ${fallback}`,
-    toJsonBody: (key, isNullable) => `"${key}": ${key}${isNullable ? "?" : ""}.toList()`
-  },
-  "List<Uint8List>": {
-    fromJsonBody: (key, fallback) => `${key}: json["${key}"] is List && (json["${key}"] as List).isNotEmpty && (json["${key}"] as List).first is List ? json["${key}"] : ${fallback}`,
-    toJsonBody: (key, isNullable) => `"${key}": ${key}${isNullable ? "?" : ""}.map((val) => val.toList()).toList()`
-  }
-};
-function defaultFromJsonBody(key, typename, fallback) {
-  return `${key}: json["${key}"] is ${typename} ? json["${key}"] : ${fallback}`;
-}
-function defaultListFromJsonBody(key, typename, fallback) {
-  return `${key}: json["${key}"] is List<${typename}> ? json["${key}"] : ${fallback}`;
-}
-function defaultToJsonBody(key) {
-  return `"${key}": ${key}`;
-}
-const classTransformer = (typename, nullable) => {
-  return {
-    fromJsonBody: (key, fallback) => {
-      if (nullable) {
-        return `${key}: json["${key}"] is Map<String, dynamic> ? 
-                ${typename}.fromJson(json["${key}"]) : null`;
-      }
-      return `${key}: ${typename}.fromJson(json["${key}"])`;
-    },
-    toJsonBody: (key, isNullable) => `"${key}": ${key}${isNullable ? "?" : ""}.toJson()`
-  };
-};
-const classListTransformer = (typename) => {
-  return {
-    fromJsonBody: (key, fallback) => {
-      return `${key}: json["${key}"] is List<Map<String, dynamic>> ? 
-                (json["${key}"] as List<Map<String, dynamic>>)
-                    .map((val) => ${typename}.fromJson(val)).toList() : ${fallback}`;
-    },
-    toJsonBody: (key, isNullable) => `"${key}": ${key}${isNullable ? "?" : ""}.map((val) => val.toJson()).toList()`
-  };
-};
-function isDartType(input) {
-  if (typeof input !== "string") {
-    return false;
-  }
-  for (const val of Object.values(dartTypeMap)) {
-    if (input === val) {
-      return true;
-    }
-    if (input.replace("List<", "").replace(">", "") === val) {
-      return true;
-    }
-  }
-  return false;
-}
-function isDartTypeWithNullables(input) {
-  if (typeof input !== "string") {
-    return false;
-  }
-  for (const val of Object.values(dartTypeMap)) {
-    if (input.replace("?", "") === val) {
-      return true;
-    }
-    if (input.replace("?", "").replace("List<", "").replace(">", "") === val) {
-      return true;
-    }
-  }
-  return false;
-}
-
-export { classListTransformer, classTransformer, createDartClient, createTypescriptClient, dartClientGenerator, dartModelFromJsonSchema, dartParsedJsonField, dartPropertyTypeFromSchema, dartServiceFromServiceDefinition, defineClientGeneratorPlugin, isDartType, isDartTypeWithNullables, transformers, tsModelFromDefinition, tsRpcFromProcedureDefinition, tsServiceFromServiceDefinition, typescriptClientGenerator };
+export { format2 as f };