'use strict';

var jsonSchemaToZodOriginal = require('json-schema-to-zod');

function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }

var jsonSchemaToZodOriginal__default = /*#__PURE__*/_interopDefault(jsonSchemaToZodOriginal);

function parseObject(objectSchema, refs) {
  let properties = void 0;
  if (objectSchema.properties) {
    if (!Object.keys(objectSchema.properties).length) {
      properties = "z.object({})";
    } else {
      properties = "z.object({ ";
      properties += Object.keys(objectSchema.properties).map((key) => {
        const propSchema = objectSchema.properties[key];
        let result = `${JSON.stringify(key)}: ${jsonSchemaToZodOriginal.parseSchema(propSchema, {
          ...refs,
          path: [...refs.path, "properties", key]
        })}`;
        if (refs.withJsdocs && typeof propSchema === "object") {
          result = jsonSchemaToZodOriginal.addJsdocs(propSchema, result);
        }
        const hasDefault = typeof propSchema === "object" && propSchema.default !== void 0;
        const required = Array.isArray(objectSchema.required) ? objectSchema.required.includes(key) : typeof propSchema === "object" && propSchema.required === true;
        const optional = !hasDefault && !required;
        return optional ? `${result}.optional()` : result;
      }).join(", ");
      properties += " })";
    }
  }
  const additionalProperties = objectSchema.additionalProperties !== void 0 && objectSchema.additionalProperties !== false ? jsonSchemaToZodOriginal.parseSchema(objectSchema.additionalProperties, {
    ...refs,
    path: [...refs.path, "additionalProperties"]
  }) : void 0;
  let patternProperties = void 0;
  if (objectSchema.patternProperties) {
    const parsedPatternProperties = Object.fromEntries(
      Object.entries(objectSchema.patternProperties).map(([key, value]) => {
        return [
          key,
          jsonSchemaToZodOriginal.parseSchema(value, {
            ...refs,
            path: [...refs.path, "patternProperties", key]
          })
        ];
      }, {})
    );
    patternProperties = "";
    if (properties) {
      if (additionalProperties) {
        patternProperties += `.catchall(z.union([${[
          ...Object.values(parsedPatternProperties),
          additionalProperties
        ].join(", ")}]))`;
      } else if (Object.keys(parsedPatternProperties).length > 1) {
        patternProperties += `.catchall(z.union([${Object.values(parsedPatternProperties).join(", ")}]))`;
      } else {
        patternProperties += `.catchall(${Object.values(parsedPatternProperties)})`;
      }
    } else {
      if (additionalProperties) {
        patternProperties += `z.record(z.union([${[
          ...Object.values(parsedPatternProperties),
          additionalProperties
        ].join(", ")}]))`;
      } else if (Object.keys(parsedPatternProperties).length > 1) {
        patternProperties += `z.record(z.union([${Object.values(parsedPatternProperties).join(", ")}]))`;
      } else {
        patternProperties += `z.record(${Object.values(parsedPatternProperties)})`;
      }
    }
    patternProperties += ".superRefine((value, ctx) => {\n";
    patternProperties += "for (const key in value) {\n";
    if (additionalProperties) {
      if (objectSchema.properties) {
        patternProperties += `let evaluated = [${Object.keys(objectSchema.properties).map((key) => JSON.stringify(key)).join(", ")}].includes(key)
`;
      } else {
        patternProperties += `let evaluated = false
`;
      }
    }
    for (const key in objectSchema.patternProperties) {
      patternProperties += "if (key.match(new RegExp(" + JSON.stringify(key) + "))) {\n";
      if (additionalProperties) {
        patternProperties += "evaluated = true\n";
      }
      patternProperties += "const result = " + parsedPatternProperties[key] + ".safeParse(value[key])\n";
      patternProperties += "if (!result.success) {\n";
      patternProperties += `ctx.addIssue({
          path: [...ctx.path, key],
          code: 'custom',
          message: \`Invalid input: Key matching regex /\${key}/ must match schema\`,
          params: {
            issues: result.error.issues
          }
        })
`;
      patternProperties += "}\n";
      patternProperties += "}\n";
    }
    if (additionalProperties) {
      patternProperties += "if (!evaluated) {\n";
      patternProperties += "const result = " + additionalProperties + ".safeParse(value[key])\n";
      patternProperties += "if (!result.success) {\n";
      patternProperties += `ctx.addIssue({
          path: [...ctx.path, key],
          code: 'custom',
          message: \`Invalid input: must match catchall schema\`,
          params: {
            issues: result.error.issues
          }
        })
`;
      patternProperties += "}\n";
      patternProperties += "}\n";
    }
    patternProperties += "}\n";
    patternProperties += "})";
  }
  let output = properties ? patternProperties ? properties + patternProperties : additionalProperties ? additionalProperties === "z.never()" ? properties + ".strict()" : properties + `.catchall(${additionalProperties})` : properties : patternProperties ? patternProperties : additionalProperties ? `z.record(${additionalProperties})` : "z.record(z.any())";
  if (jsonSchemaToZodOriginal.its.an.anyOf(objectSchema)) {
    output += `.and(${jsonSchemaToZodOriginal.parseAnyOf(
      {
        ...objectSchema,
        anyOf: objectSchema.anyOf.map(
          (x) => typeof x === "object" && !x.type && (x.properties || x.additionalProperties || x.patternProperties) ? { ...x, type: "object" } : x
        )
      },
      refs
    )})`;
  }
  if (jsonSchemaToZodOriginal.its.a.oneOf(objectSchema)) {
    output += `.and(${jsonSchemaToZodOriginal.parseOneOf(
      {
        ...objectSchema,
        oneOf: objectSchema.oneOf.map(
          (x) => typeof x === "object" && !x.type && (x.properties || x.additionalProperties || x.patternProperties) ? { ...x, type: "object" } : x
        )
      },
      refs
    )})`;
  }
  if (jsonSchemaToZodOriginal.its.an.allOf(objectSchema)) {
    output += `.and(${jsonSchemaToZodOriginal.parseAllOf(
      {
        ...objectSchema,
        allOf: objectSchema.allOf.map(
          (x) => typeof x === "object" && !x.type && (x.properties || x.additionalProperties || x.patternProperties) ? { ...x, type: "object" } : x
        )
      },
      refs
    )})`;
  }
  return output;
}
var parserOverride = (schema, refs) => {
  let parsed = "";
  let seen = refs.seen.get(schema);
  if (jsonSchemaToZodOriginal.its.an.anyOf(schema)) {
    const allObjects = schema.anyOf.every(
      (item) => typeof item === "object" && jsonSchemaToZodOriginal.its.an.object(item) && item.properties !== void 0
    );
    if (schema.anyOf.length > 1 && allObjects) {
      const propertiesWithConst = schema.anyOf.reduce((acc, item) => {
        if (typeof item === "object" && jsonSchemaToZodOriginal.its.an.object(item)) {
          const propertyWithConst = Object.entries(item.properties ?? {}).filter(
            ([_, value]) => typeof value === "object" && value?.const !== void 0
          );
          if (propertyWithConst?.length) {
            const ppties = propertyWithConst.map(([key, _]) => key);
            acc.push(ppties);
          }
        }
        return acc;
      }, []);
      if (propertiesWithConst.length === schema.anyOf.length) {
        if (seen) {
          if (seen.r !== void 0) {
            return seen.r;
          }
          if (refs.depth === void 0 || seen.n >= refs.depth) {
            return "z.any()";
          }
          seen.n += 1;
        } else {
          seen = { r: void 0, n: 0 };
          refs.seen.set(schema, seen);
        }
        const discriminators = propertiesWithConst.length > 0 && propertiesWithConst[0] ? propertiesWithConst.reduce((common, properties) => {
          return common.filter((prop) => properties.includes(prop));
        }, propertiesWithConst[0]) : [];
        if (discriminators.length > 0) {
          const discriminator = discriminators[0];
          if (discriminator) {
            parsed = `z.discriminatedUnion("${discriminator}", [${schema.anyOf.map(
              (schema2, i) => jsonSchemaToZodOriginal.parseSchema(schema2, {
                ...refs,
                path: [...refs.path, "anyOf", i]
              })
            ).join(", ")}])`;
          }
        }
      }
    }
  } else if (jsonSchemaToZodOriginal.its.an.object(schema)) {
    if (seen) {
      if (seen.r !== void 0) {
        return seen.r;
      }
      if (refs.depth === void 0 || seen.n >= refs.depth) {
        return "z.any()";
      }
      seen.n += 1;
    } else {
      seen = { r: void 0, n: 0 };
      refs.seen.set(schema, seen);
    }
    parsed = parseObject(schema, refs);
  }
  if (parsed) {
    if (!refs.withoutDescribes) {
      parsed = addDescribes(schema, parsed);
    }
    if (!refs.withoutDefaults) {
      parsed = addDefaults(schema, parsed);
    }
    parsed = addAnnotations(schema, parsed);
    if (seen) {
      seen.r = parsed;
    }
    return parsed;
  }
};
var addDescribes = (schema, parsed) => {
  if (schema.description) {
    parsed += `.describe(${JSON.stringify(schema.description)})`;
  }
  return parsed;
};
var addDefaults = (schema, parsed) => {
  if (schema.default !== void 0) {
    parsed += `.default(${JSON.stringify(schema.default)})`;
  }
  return parsed;
};
var addAnnotations = (schema, parsed) => {
  if (schema.readOnly) {
    parsed += ".readonly()";
  }
  return parsed;
};
function jsonSchemaToZod(schema, options = {}) {
  const result = jsonSchemaToZodOriginal__default.default(schema, { ...options, parserOverride });
  return result.replace(/\.reduce<[^>]+>/g, ".reduce");
}

exports.jsonSchemaToZod = jsonSchemaToZod;
Object.keys(jsonSchemaToZodOriginal).forEach(function (k) {
  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
    enumerable: true,
    get: function () { return jsonSchemaToZodOriginal[k]; }
  });
});
//# sourceMappingURL=json-to-zod.cjs.map
//# sourceMappingURL=json-to-zod.cjs.map