@calcom/atoms 2.8.0 → 2.8.2

package/src/vendor/form-builder/__tests__/base-schema.test.ts

@@ -1,109 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  baseFieldSchema,
-  EditableSchema,
-  eventTypeBookingFields,
-  excludeOrRequireEmailSchema,
-  fieldSchema,
-  variantsConfigSchema,
-} from "../base-schema";
-
-describe("excludeOrRequireEmailSchema", () => {
-  it("accepts an empty string", () => {
-    expect(excludeOrRequireEmailSchema.safeParse("").success).toBe(true);
-  });
-
-  it("accepts a valid domain", () => {
-    expect(excludeOrRequireEmailSchema.safeParse("example.com").success).toBe(true);
-  });
-
-  it("accepts multiple comma-separated domains", () => {
-    expect(excludeOrRequireEmailSchema.safeParse("example.com, foo.co.uk").success).toBe(true);
-  });
-
-  it("accepts a full email address", () => {
-    expect(excludeOrRequireEmailSchema.safeParse("alice@example.com").success).toBe(true);
-  });
-
-  it("rejects an obviously invalid string", () => {
-    expect(excludeOrRequireEmailSchema.safeParse("not a domain !!").success).toBe(false);
-  });
-});
-
-describe("EditableSchema", () => {
-  it("accepts canonical editable values", () => {
-    for (const val of ["system", "system-but-optional", "system-but-hidden", "user", "user-readonly"]) {
-      expect(EditableSchema.safeParse(val).success).toBe(true);
-    }
-  });
-
-  it("rejects unknown editable values", () => {
-    expect(EditableSchema.safeParse("other").success).toBe(false);
-  });
-});
-
-describe("baseFieldSchema", () => {
-  it("requires name and type", () => {
-    expect(baseFieldSchema.safeParse({}).success).toBe(false);
-  });
-
-  it("normalizes name to a valid RHF field name", () => {
-    const parsed = baseFieldSchema.parse({ name: "first name!", type: "text" });
-    expect(parsed.name).toBe("first-name-");
-  });
-
-  it("parses options with coerced price", () => {
-    const parsed = baseFieldSchema.parse({
-      name: "choice",
-      type: "select",
-      options: [{ label: "A", value: "a", price: "100" as unknown as number }],
-    });
-    expect(parsed.options?.[0]?.price).toBe(100);
-  });
-
-  it("rejects negative price", () => {
-    expect(
-      baseFieldSchema.safeParse({
-        name: "p",
-        type: "number",
-        price: -1,
-      }).success
-    ).toBe(false);
-  });
-});
-
-describe("variantsConfigSchema", () => {
-  it("accepts a valid variants config", () => {
-    const parsed = variantsConfigSchema.parse({
-      variants: {
-        fullName: {
-          fields: [{ name: "fullName", type: "text" }],
-        },
-      },
-    });
-    expect(parsed.variants.fullName?.fields[0]?.name).toBe("fullName");
-  });
-});
-
-describe("fieldSchema and eventTypeBookingFields", () => {
-  it("accepts an empty array of fields", () => {
-    expect(eventTypeBookingFields.parse([])).toEqual([]);
-  });
-
-  it("accepts editable=user", () => {
-    const parsed = fieldSchema.parse({ name: "x", type: "text", editable: "user" });
-    expect(parsed.editable).toBe("user");
-  });
-
-  it("accepts a field with variantsConfig and sources", () => {
-    const parsed = fieldSchema.parse({
-      name: "name",
-      type: "name",
-      variant: "firstAndLastName",
-      variantsConfig: { variants: { firstAndLastName: { fields: [{ name: "firstName", type: "text" }] } } },
-      sources: [{ id: "default", type: "system", label: "System" }],
-    });
-    expect(parsed.variant).toBe("firstAndLastName");
-    expect(parsed.sources?.[0]?.type).toBe("system");
-  });
-});

package/src/vendor/form-builder/__tests__/schema.test.ts

@@ -1,245 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { fieldTypesSchemaMap } from "../schema";
-
-type Issue = { code: string; message: string };
-function makeCtx() {
-  const issues: Issue[] = [];
-  const ctx = {
-    addIssue: vi.fn((issue: Issue) => issues.push(issue)),
-  };
-  return { ctx, issues };
-}
-const m = (key: string) => key;
-
-describe("fieldTypesSchemaMap.name", () => {
-  const nameSchema = fieldTypesSchemaMap.name;
-  const baseField = {
-    type: "name" as const,
-    name: "name",
-    required: true,
-    variant: "fullName",
-  };
-
-  describe("preprocess", () => {
-    it("returns empty string when response is null/undefined", () => {
-      expect(nameSchema.preprocess({ field: baseField, response: null, isPartialSchema: false })).toBe("");
-      expect(nameSchema.preprocess({ field: baseField, response: undefined, isPartialSchema: false })).toBe(
-        ""
-      );
-    });
-
-    it("returns string as-is for fullName variant", () => {
-      const out = nameSchema.preprocess({
-        field: baseField,
-        response: "Alice Doe",
-        isPartialSchema: false,
-      });
-      expect(out).toBe("Alice Doe");
-    });
-
-    it("parses JSON string with firstName/lastName and returns fullName string", () => {
-      const out = nameSchema.preprocess({
-        field: baseField,
-        response: JSON.stringify({ firstName: "Alice", lastName: "Doe" }),
-        isPartialSchema: false,
-      });
-      expect(out).toBe("Alice Doe");
-    });
-
-    it("treats invalid JSON as regular string", () => {
-      const out = nameSchema.preprocess({
-        field: baseField,
-        response: "{not json",
-        isPartialSchema: false,
-      });
-      expect(out).toBe("{not json");
-    });
-
-    it("handles firstAndLastName variant with object input", () => {
-      const out = nameSchema.preprocess({
-        field: { ...baseField, variant: "firstAndLastName" },
-        response: { firstName: "Alice", lastName: "Doe" },
-        isPartialSchema: false,
-      });
-      expect(out).toEqual({ firstName: "Alice", lastName: "Doe" });
-    });
-
-    it("falls back to fullName when variant is unknown", () => {
-      const out = nameSchema.preprocess({
-        field: { ...baseField, variant: "bogus" as unknown as "fullName" },
-        response: { firstName: "Alice", lastName: "Doe" },
-        isPartialSchema: false,
-      });
-      expect(out).toBe("Alice Doe");
-    });
-
-    it("returns empty string for object without firstName string", () => {
-      const out = nameSchema.preprocess({
-        field: baseField,
-        response: { foo: "bar" } as unknown,
-        isPartialSchema: false,
-      });
-      expect(out).toBe("");
-    });
-  });
-
-  describe("superRefine", () => {
-    it("no issue for non-empty required fullName", () => {
-      const { ctx, issues } = makeCtx();
-      nameSchema.superRefine({
-        field: baseField,
-        response: "Alice",
-        isPartialSchema: false,
-        ctx,
-        m,
-      });
-      expect(issues).toHaveLength(0);
-    });
-
-    it("adds issue when required fullName is empty string", () => {
-      const { ctx, issues } = makeCtx();
-      nameSchema.superRefine({
-        field: baseField,
-        response: "",
-        isPartialSchema: false,
-        ctx,
-        m,
-      });
-      expect(issues).toHaveLength(1);
-      expect(issues[0].message).toBe("Invalid string");
-    });
-
-    it("no issue for firstAndLastName when subfields supplied", () => {
-      const { ctx, issues } = makeCtx();
-      nameSchema.superRefine({
-        field: { ...baseField, variant: "firstAndLastName" },
-        response: { firstName: "Alice", lastName: "Doe" } as unknown as Record<string, string>,
-        isPartialSchema: false,
-        ctx,
-        m,
-      });
-      expect(issues).toHaveLength(0);
-    });
-  });
-});
-
-describe("fieldTypesSchemaMap.textarea", () => {
-  const textareaSchema = fieldTypesSchemaMap.textarea;
-  const baseField = {
-    type: "textarea" as const,
-    name: "notes",
-    required: false,
-    maxLength: 10,
-    minLength: 0,
-  };
-
-  it("preprocess stringifies and trims the response", () => {
-    expect(
-      textareaSchema.preprocess({ field: baseField, response: "  hello ", isPartialSchema: false })
-    ).toBe("hello");
-    expect(textareaSchema.preprocess({ field: baseField, response: 42, isPartialSchema: false })).toBe("42");
-  });
-
-  it("adds issue when exceeding maxLength", () => {
-    const { ctx, issues } = makeCtx();
-    textareaSchema.superRefine({
-      field: baseField,
-      response: "12345678901",
-      isPartialSchema: false,
-      ctx,
-      m,
-    });
-    expect(issues).toHaveLength(1);
-    expect(issues[0].message).toContain("max_characters_allowed");
-  });
-
-  it("adds issue when below minLength", () => {
-    const { ctx, issues } = makeCtx();
-    textareaSchema.superRefine({
-      field: { ...baseField, minLength: 5 },
-      response: "ab",
-      isPartialSchema: false,
-      ctx,
-      m,
-    });
-    expect(issues).toHaveLength(1);
-    expect(issues[0].message).toContain("min_characters_required");
-  });
-
-  it("no issue when within bounds", () => {
-    const { ctx, issues } = makeCtx();
-    textareaSchema.superRefine({
-      field: baseField,
-      response: "ok",
-      isPartialSchema: false,
-      ctx,
-      m,
-    });
-    expect(issues).toHaveLength(0);
-  });
-});
-
-describe("fieldTypesSchemaMap.url", () => {
-  const urlSchema = fieldTypesSchemaMap.url;
-  const baseField = {
-    type: "url" as const,
-    name: "website",
-    required: false,
-  };
-
-  it("preprocess stringifies and trims", () => {
-    expect(
-      urlSchema.preprocess({ field: baseField, response: "  http://x.com  ", isPartialSchema: false })
-    ).toBe("http://x.com");
-  });
-
-  it("accepts a valid https URL with no issues", () => {
-    const { ctx, issues } = makeCtx();
-    urlSchema.superRefine({
-      field: baseField,
-      response: "https://example.com/path",
-      isPartialSchema: false,
-      ctx,
-      m,
-    });
-    expect(issues).toHaveLength(0);
-  });
-
-  it("accepts a bare domain by prepending https://", () => {
-    const { ctx, issues } = makeCtx();
-    urlSchema.superRefine({
-      field: baseField,
-      response: "example.com/path",
-      isPartialSchema: false,
-      ctx,
-      m,
-    });
-    expect(issues).toHaveLength(0);
-  });
-
-  it("rejects malformed http:/ URLs", () => {
-    const { ctx, issues } = makeCtx();
-    urlSchema.superRefine({
-      field: baseField,
-      response: "http:/example.com",
-      isPartialSchema: false,
-      ctx,
-      m,
-    });
-    expect(issues).toHaveLength(1);
-    expect(issues[0].message).toBe("url_validation_error");
-  });
-
-  it("rejects garbage strings", () => {
-    const { ctx, issues } = makeCtx();
-    urlSchema.superRefine({
-      field: baseField,
-      response: "not a url at all",
-      isPartialSchema: false,
-      ctx,
-      m,
-    });
-    expect(issues).toHaveLength(1);
-    expect(issues[0].message).toBe("url_validation_error");
-  });
-});

package/src/vendor/form-builder/__tests__/system-field.test.ts

@@ -1,57 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  CAL_AI_AGENT_PHONE_NUMBER_FIELD,
-  SMS_REMINDER_NUMBER_FIELD,
-  SYSTEM_PHONE_FIELDS,
-  SystemField,
-  shouldShowFieldInCustomResponses,
-  TITLE_FIELD,
-} from "../system-field";
-
-describe("SystemField enum", () => {
-  it("parses every canonical system field name", () => {
-    for (const field of [
-      "name",
-      "email",
-      "location",
-      "title",
-      "notes",
-      "guests",
-      "rescheduleReason",
-      "smsReminderNumber",
-      "attendeePhoneNumber",
-      "aiAgentCallPhoneNumber",
-    ]) {
-      expect(SystemField.safeParse(field).success).toBe(true);
-    }
-  });
-
-  it("rejects non-system names", () => {
-    expect(SystemField.safeParse("custom").success).toBe(false);
-  });
-});
-
-describe("SYSTEM_PHONE_FIELDS", () => {
-  it("contains the three phone fields", () => {
-    expect(SYSTEM_PHONE_FIELDS.has(SMS_REMINDER_NUMBER_FIELD)).toBe(true);
-    expect(SYSTEM_PHONE_FIELDS.has(CAL_AI_AGENT_PHONE_NUMBER_FIELD)).toBe(true);
-    expect(SYSTEM_PHONE_FIELDS.has("attendeePhoneNumber")).toBe(true);
-  });
-});
-
-describe("shouldShowFieldInCustomResponses", () => {
-  it("hides regular system fields", () => {
-    expect(shouldShowFieldInCustomResponses("name")).toBe(false);
-    expect(shouldShowFieldInCustomResponses("email")).toBe(false);
-    expect(shouldShowFieldInCustomResponses("location")).toBe(false);
-  });
-
-  it("shows smsReminderNumber and title even though they are system fields", () => {
-    expect(shouldShowFieldInCustomResponses(SMS_REMINDER_NUMBER_FIELD)).toBe(true);
-    expect(shouldShowFieldInCustomResponses(TITLE_FIELD)).toBe(true);
-  });
-
-  it("shows any non-system field", () => {
-    expect(shouldShowFieldInCustomResponses("custom")).toBe(true);
-  });
-});

package/src/vendor/form-builder/__tests__/use-should-be-disabled-due-to-prefill.test.ts

@@ -1,24 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { getFieldNameFromErrorMessage } from "../use-should-be-disabled-due-to-prefill";
-
-describe("getFieldNameFromErrorMessage", () => {
-  it("extracts the field name when wrapped in {name}", () => {
-    expect(getFieldNameFromErrorMessage("{email} is required")).toBe("email");
-  });
-
-  it("extracts the field name with trailing text", () => {
-    expect(getFieldNameFromErrorMessage("{phone} must be valid phone number")).toBe("phone");
-  });
-
-  it("returns the original string when no braces are present", () => {
-    expect(getFieldNameFromErrorMessage("global required error")).toBe("global required error");
-  });
-
-  it("handles empty string inputs", () => {
-    expect(getFieldNameFromErrorMessage("")).toBe("");
-  });
-
-  it("returns the first braced token only", () => {
-    expect(getFieldNameFromErrorMessage("{first}{second}")).toBe("first");
-  });
-});

package/src/vendor/form-builder/__tests__/utils.test.ts

@@ -1,83 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { getFullName, getValidRhfFieldName, preprocessNameFieldDataWithVariant } from "../utils";
-
-describe("getFullName", () => {
-  it("returns empty string for undefined name", () => {
-    expect(getFullName(undefined)).toBe("");
-  });
-
-  it("returns string input as-is", () => {
-    expect(getFullName("Alice")).toBe("Alice");
-  });
-
-  it("combines firstName and lastName for object input", () => {
-    expect(getFullName({ firstName: "Alice", lastName: "Doe" })).toBe("Alice Doe");
-  });
-
-  it("returns only firstName when lastName is missing", () => {
-    expect(getFullName({ firstName: "Alice" })).toBe("Alice");
-  });
-
-  it("returns only firstName when lastName is empty string", () => {
-    expect(getFullName({ firstName: "Alice", lastName: "" })).toBe("Alice");
-  });
-});
-
-describe("preprocessNameFieldDataWithVariant", () => {
-  it("calls getFullName when variant is fullName with string input", () => {
-    expect(preprocessNameFieldDataWithVariant("fullName", "Alice")).toBe("Alice");
-  });
-
-  it("calls getFullName when variant is fullName with object input", () => {
-    expect(preprocessNameFieldDataWithVariant("fullName", { firstName: "Alice", lastName: "Doe" })).toBe(
-      "Alice Doe"
-    );
-  });
-
-  it("returns firstName/lastName object when variant is firstAndLastName with JSON string input", () => {
-    const out = preprocessNameFieldDataWithVariant(
-      "firstAndLastName",
-      JSON.stringify({ firstName: "Alice", lastName: "Doe" })
-    );
-    expect(out).toEqual({ firstName: "Alice", lastName: "Doe" });
-  });
-
-  it("splits plain string on whitespace for firstAndLastName", () => {
-    const out = preprocessNameFieldDataWithVariant("firstAndLastName", "Alice Mary Doe");
-    expect(out).toEqual({ firstName: "Alice", lastName: "Mary Doe" });
-  });
-
-  it("returns single-field object for plain single string in firstAndLastName", () => {
-    const out = preprocessNameFieldDataWithVariant("firstAndLastName", "Alice");
-    expect(out).toEqual({ firstName: "Alice", lastName: "" });
-  });
-
-  it("passes through object for firstAndLastName variant", () => {
-    const out = preprocessNameFieldDataWithVariant("firstAndLastName", {
-      firstName: "Alice",
-      lastName: "Doe",
-    });
-    expect(out).toEqual({ firstName: "Alice", lastName: "Doe" });
-  });
-
-  it("returns empty-object-like split for undefined firstAndLastName", () => {
-    const out = preprocessNameFieldDataWithVariant("firstAndLastName", undefined);
-    expect(out).toEqual({ firstName: "", lastName: "" });
-  });
-});
-
-describe("getValidRhfFieldName", () => {
-  it("passes through alphanumeric and underscore/hyphen names unchanged", () => {
-    expect(getValidRhfFieldName("my_field-name123")).toBe("my_field-name123");
-  });
-
-  it("replaces whitespace and special characters with hyphens", () => {
-    expect(getValidRhfFieldName("my field name")).toBe("my-field-name");
-    expect(getValidRhfFieldName("my.field@name")).toBe("my-field-name");
-    expect(getValidRhfFieldName("a!b#c$d")).toBe("a-b-c-d");
-  });
-
-  it("returns empty string for empty input", () => {
-    expect(getValidRhfFieldName("")).toBe("");
-  });
-});

package/src/vendor/form-builder/base-schema.ts

@@ -1,127 +0,0 @@
-import { z } from "zod";
-
-import { fieldTypeEnum } from "./field-type-enum";
-import { getValidRhfFieldName } from "./utils";
-
-export const excludeOrRequireEmailSchema = z.string().superRefine((val, ctx) => {
-  if (val.trim() === "") return;
-
-  const allDomains = val
-    .split(",")
-    .map((dom) => dom.trim())
-    .filter(Boolean);
-
-  if (allDomains.length === 0) {
-    ctx.addIssue({
-      code: z.ZodIssueCode.custom,
-      message: "Enter valid domain or email",
-    });
-    return;
-  }
-
-  const EMAIL_OR_DOMAIN_PATTERN =
-    /^(?:[a-z0-9._+'-]+@|@)?(?:[a-z]{2,}|(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z]{2,})$/i;
-
-  const isValid = allDomains.every((entry) => EMAIL_OR_DOMAIN_PATTERN.test(entry));
-
-  if (!isValid) {
-    ctx.addIssue({
-      code: z.ZodIssueCode.custom,
-      message: "Enter valid domain or email",
-    });
-  }
-});
-
-export const EditableSchema = z.enum([
-  "system",
-  "system-but-optional",
-  "system-but-hidden",
-  "user",
-  "user-readonly",
-]);
-
-export const baseFieldSchema = z.object({
-  name: z.string().transform(getValidRhfFieldName),
-  type: fieldTypeEnum,
-  label: z.string().optional(),
-  labelAsSafeHtml: z.string().optional(),
-  defaultLabel: z.string().optional(),
-  placeholder: z.string().optional(),
-  defaultPlaceholder: z.string().optional(),
-  required: z.boolean().default(false).optional(),
-  options: z
-    .array(
-      z.object({
-        label: z.string(),
-        value: z.string(),
-        price: z.coerce.number().min(0).optional(),
-      })
-    )
-    .optional(),
-  getOptionsAt: z.string().optional(),
-  optionsInputs: z
-    .record(
-      z.object({
-        type: z.enum(["address", "phone", "text"]),
-        required: z.boolean().optional(),
-        placeholder: z.string().optional(),
-      })
-    )
-    .optional(),
-  minLength: z.number().optional(),
-  maxLength: z.number().optional(),
-  excludeEmails: excludeOrRequireEmailSchema.optional(),
-  requireEmails: excludeOrRequireEmailSchema.optional(),
-  price: z.coerce.number().min(0).optional(),
-});
-
-export const variantsConfigSchema = z.object({
-  variants: z.record(
-    z.object({
-      fields: baseFieldSchema
-        .omit({
-          defaultLabel: true,
-          defaultPlaceholder: true,
-          options: true,
-          getOptionsAt: true,
-          optionsInputs: true,
-        })
-        .array(),
-    })
-  ),
-});
-
-export const fieldSourceSchema = z.object({
-  id: z.string(),
-  type: z.union([z.literal("user"), z.literal("system"), z.string()]),
-  label: z.string(),
-  editUrl: z.string().optional(),
-  fieldRequired: z.boolean().optional(),
-  subType: z.enum(["sms", "calai"]).optional(),
-});
-
-export type FieldSource = z.infer<typeof fieldSourceSchema>;
-
-export const fieldSchema = baseFieldSchema.merge(
-  z.object({
-    variant: z.string().optional(),
-    variantsConfig: variantsConfigSchema.optional(),
-    views: z
-      .object({
-        label: z.string(),
-        id: z.string(),
-        description: z.string().optional(),
-      })
-      .array()
-      .optional(),
-    hideWhenJustOneOption: z.boolean().default(false).optional(),
-    hidden: z.boolean().optional(),
-    editable: EditableSchema.default("user").optional(),
-    sources: z.array(fieldSourceSchema).optional(),
-    disableOnPrefill: z.boolean().default(false).optional(),
-  })
-);
-
-export const eventTypeBookingFields = z.array(fieldSchema);
-export type EventTypeBookingFields = z.infer<typeof eventTypeBookingFields>;
-export const BookingFieldTypeEnum = eventTypeBookingFields.element.shape.type.Enum;

package/src/vendor/form-builder/field-type-enum.ts

@@ -1,21 +0,0 @@
-import { z } from "zod";
-
-export const fieldTypeEnum = z.enum([
-  "name",
-  "text",
-  "textarea",
-  "number",
-  "email",
-  "phone",
-  "address",
-  "multiemail",
-  "select",
-  "multiselect",
-  "checkbox",
-  "radio",
-  "radioInput",
-  "boolean",
-  "url",
-]);
-
-export type FieldType = z.infer<typeof fieldTypeEnum>;