@eristack/person/dist/zod/index.cjs

Structured person name and gender identity — normalize and display, not HRIS

"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/zod/index.ts
var zod_exports = {};
__export(zod_exports, {
  personSchema: () => personSchema
});
module.exports = __toCommonJS(zod_exports);

// src/zod/schemas.ts
var import_zod = require("zod");

// src/core/errors.ts
var PERSON_PARSE_CODE = "PERSON_PARSE";
var PersonParseError = class extends Error {
  code = PERSON_PARSE_CODE;
  constructor(message) {
    super(message);
    this.name = "PersonParseError";
  }
};

// src/core/types.ts
var GENDER_IDENTITIES = [
  "unknown",
  "woman",
  "man",
  "non_binary",
  "prefer_not_to_say",
  "other"
];

// src/core/person.ts
function trimOptional(value) {
  const t = value?.trim();
  return t ? t : void 0;
}
function trimRequired(value, field) {
  const t = value.trim();
  if (!t) {
    throw new PersonParseError(`${field} is required`);
  }
  return t;
}
function normalizePersonName(input) {
  return {
    given: trimRequired(input.given, "name.given"),
    family: trimRequired(input.family, "name.family"),
    middle: trimOptional(input.middle),
    prefix: trimOptional(input.prefix),
    suffix: trimOptional(input.suffix)
  };
}
function isGenderIdentity(value) {
  return GENDER_IDENTITIES.includes(value);
}
function normalizeGenderIdentity(value) {
  const normalized = value.trim().toLowerCase().replace(/-/g, "_");
  if (!isGenderIdentity(normalized)) {
    throw new PersonParseError(`Invalid gender identity "${value}"`);
  }
  return normalized;
}
function normalizePerson(input) {
  const name = normalizePersonName(input.name);
  const gender = input.gender ? normalizeGenderIdentity(input.gender) : void 0;
  const genderOther = trimOptional(input.genderOther);
  if (gender === "other" && !genderOther) {
    throw new PersonParseError("genderOther is required when gender is other");
  }
  if (gender !== "other" && genderOther) {
    throw new PersonParseError("genderOther is only allowed when gender is other");
  }
  return { name, gender, genderOther };
}

// src/zod/schemas.ts
var personNameSchema = import_zod.z.object({
  given: import_zod.z.string(),
  family: import_zod.z.string(),
  middle: import_zod.z.string().optional(),
  prefix: import_zod.z.string().optional(),
  suffix: import_zod.z.string().optional()
});
var personSchema = import_zod.z.object({
  name: personNameSchema,
  gender: import_zod.z.enum([...GENDER_IDENTITIES]).optional(),
  genderOther: import_zod.z.string().optional()
}).transform((value) => normalizePerson(value));
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  personSchema
});
//# sourceMappingURL=index.cjs.map