synapse-react-client 4.0.19 → 4.0.21

package/dist/components/TableColumnSchemaEditor/Validators/ColumnModelValidator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ColumnModelValidator.d.ts","sourceRoot":"","sources":["../../../../src/components/TableColumnSchemaEditor/Validators/ColumnModelValidator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAA;AAO7E,OAAO,EAAE,KAAK,mBAAmB,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACjD,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA;AAkBvC,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;EAKvC,CAAA;AAqCD;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8D7B,CAAA;AAEJ,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAAgC,CAAA;AAEzE,QAAA,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;EAIrC,CAAA;AAED,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAC9C,OAAO,gCAAgC,CACxC,CAAA;AAGD,QAAA,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAM/B,CAAA;AAED;;;GAGG;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAA;AAE5E,wBAAgB,2BAA2B,CACzC,QAAQ,EAAE,WAAW,CACnB,mBAAmB,EACnB,2BAA2B,GAAG,YAAY,CAC3C,EAAE,GACF,mBAAmB,CACpB,WAAW,CACT,mBAAmB,EACnB,2BAA2B,GAAG,YAAY,CAC3C,EAAE,EACH,WAAW,CAAC,WAAW,EAAE,IAAI,CAAC,EAAE,CACjC,CAEA"}
+{"version":3,"file":"ColumnModelValidator.d.ts","sourceRoot":"","sources":["../../../../src/components/TableColumnSchemaEditor/Validators/ColumnModelValidator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAA;AAU7E,OAAO,EAAE,CAAC,EAAW,MAAM,KAAK,CAAA;AAChC,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA;AAuBvC,eAAO,MAAM,2BAA2B;;;;;;;;iBAGtC,CAAA;AAyDF;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2F7B,CAAA;AAEJ,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAAgC,CAAA;AAEzE,QAAA,MAAM,gCAAgC;;;;;;;;;iBAEpC,CAAA;AAEF,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAC9C,OAAO,gCAAgC,CACxC,CAAA;AAGD,QAAA,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAI9B,CAAA;AAEF;;;GAGG;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAA;AAE5E,wBAAgB,2BAA2B,CACzC,QAAQ,EAAE,WAAW,CACnB,mBAAmB,EACnB,2BAA2B,GAAG,YAAY,CAC3C,EAAE,GACF,CAAC,CAAC,kBAAkB,CAAC,WAAW,CAAC,WAAW,EAAE,IAAI,CAAC,EAAE,CAAC,CAExD"}

package/dist/components/TableColumnSchemaEditor/Validators/ColumnModelValidator.js

@@ -1,76 +1,76 @@
-import { MAX_STRING_SIZE as e, canHaveMaxListLength as t, canHaveSize as n } from "../TableColumnSchemaEditorUtils.js";
-import { getDefaultValueValidator as r } from "./DefaultValueValidator.js";
-import i from "./EnumValuesValidator.js";
-import { optionalStringSchema as a } from "./OptionalStringSchema.js";
-import { omit as o } from "lodash-es";
-import { ColumnTypeEnum as s } from "@sage-bionetworks/synapse-types";
-import { z as c } from "zod";
+import { DISALLOWED_DEFAULT_VALUE_COLUMN_TYPES as e, MAX_STRING_SIZE as t, canHaveMaxListLength as n, canHaveSize as r, getMaxListLengthForType as i } from "../TableColumnSchemaEditorUtils.js";
+import { getDefaultValueValidator as a } from "./DefaultValueValidator.js";
+import o from "./EnumValuesValidator.js";
+import { optionalStringSchema as s } from "./OptionalStringSchema.js";
+import { omit as c } from "lodash-es";
+import { ColumnTypeEnum as l } from "@sage-bionetworks/synapse-types";
+import { z as u } from "zod";
 //#region src/components/TableColumnSchemaEditor/Validators/ColumnModelValidator.ts
-var l = c.union([c.literal("enumeration"), c.literal("range")]), u = c.object({
-	property: c.enum(["FREQUENCY", "VALUE"]).optional(),
-	direction: c.enum(["DESC", "ASC"]).optional()
-}), d = c.object({
-	name: c.string().min(1, { message: "Name is required" }),
-	columnType: c.nativeEnum(s)
-}), f = d.merge(c.object({
-	jsonPath: c.string().startsWith("$"),
-	facetType: l
-})), p = d.merge(c.object({
-	id: c.string().optional(),
-	defaultValue: c.union([c.string(), c.array(c.any())]).optional(),
-	maximumSize: c.union([a, c.number()]).pipe(c.coerce.number().finite().int().min(1).max(e).optional()),
-	maximumListLength: c.union([a, c.number()]).pipe(c.coerce.number().finite().int().min(1).max(100).optional()),
-	enumValues: c.array(c.union([c.string(), c.number().int()]).pipe(c.coerce.string())).optional(),
-	jsonSubColumns: c.array(f).optional(),
-	facetType: l.optional(),
-	facetSortConfig: u.optional()
-})), m = p.refine((e) => e.maximumSize == null || n(e.columnType), {
+var d = u.enum(["enumeration", "range"]), f = u.object({
+	property: u.enum(["FREQUENCY", "VALUE"]).optional(),
+	direction: u.enum(["DESC", "ASC"]).optional()
+}), p = u.object({
+	name: u.string().min(1, { message: "Name is required" }).max(256, { message: "Name must be 256 characters or fewer" }),
+	columnType: u.enum(l)
+}), m = p.extend({
+	jsonPath: u.string().startsWith("$"),
+	facetType: d
+}), h = p.extend({
+	id: u.string().optional(),
+	defaultValue: u.union([u.string(), u.array(u.any())]).optional(),
+	maximumSize: u.union([s, u.number()]).transform((e) => typeof e == "string" ? Number(e) : e).pipe(u.number().int().min(1).max(t).optional()),
+	maximumListLength: u.union([s, u.number()]).transform((e) => typeof e == "string" ? Number(e) : e).pipe(u.number().int().min(1).optional()),
+	enumValues: u.array(u.union([u.string(), u.number().int()]).pipe(u.coerce.string())).max(100, { message: "A column may have at most 100 enumeration values" }).optional(),
+	jsonSubColumns: u.array(m).optional(),
+	facetType: d.optional(),
+	facetSortConfig: f.optional()
+});
+function g(e, t, n, r) {
+	let i = t.safeParse(e);
+	if (i.success) return i.data;
+	i.error.issues.forEach((e) => {
+		r.addIssue({
+			...e,
+			path: [n]
+		});
+	});
+}
+var _ = h.refine((e) => e.maximumSize == null || r(e.columnType), {
 	message: "Size is not allowed for this column type",
 	path: ["maximumSize"]
-}).refine((e) => e.maximumListLength == null || t(e.columnType), {
+}).refine((e) => e.maximumListLength == null || n(e.columnType), {
 	message: "Maximum list length is not allowed for this column type",
 	path: ["maximumListLength"]
-}).refine((e) => e.jsonSubColumns == null ? !0 : e.columnType === s.JSON, {
+}).superRefine((e, t) => {
+	if (e.maximumListLength == null || !n(e.columnType)) return;
+	let r = i(e.columnType, e.maximumSize);
+	e.maximumListLength > r && t.addIssue({
+		code: "custom",
+		message: `Maximum list length must not exceed ${r} for this column type and element size`,
+		path: ["maximumListLength"]
+	});
+}).refine((e) => e.jsonSubColumns == null ? !0 : e.columnType === l.JSON, {
 	message: "Only JSON columns can have JSON sub-columns.",
 	path: ["columnType"]
-}).transform((e, t) => {
-	if (e.defaultValue != null) {
-		let n = r(e.columnType).safeParse(e.defaultValue), i;
-		return n.success ? i = n.data : (n.error.issues.forEach((e) => {
-			t.addIssue({
-				...e,
-				path: ["defaultValue"]
-			});
-		}), i = void 0), {
-			...e,
-			defaultValue: i
-		};
-	}
-	return o(e, "defaultValue");
-}).transform((e, t) => {
-	if (e.enumValues != null) {
-		let n = i(e.columnType).safeParse(e.enumValues), r;
-		return n.success ? r = n.data : (n.error.issues.forEach((e) => {
-			t.addIssue({
-				...e,
-				path: ["enumValues"]
-			});
-		}), r = void 0), {
-			...e,
-			enumValues: r
-		};
-	}
-	return o(e, "enumValues");
-}), h = c.array(m), g = f.merge(c.object({ isSelected: c.boolean() }));
-p.merge(c.object({
-	isSelected: c.boolean(),
-	isOriginallyDefaultColumn: c.boolean(),
-	jsonSubColumns: c.array(g).optional()
-}));
-function _(e) {
-	return h.safeParse(e);
+}).refine((t) => !(t.defaultValue != null && t.defaultValue !== "" && !(Array.isArray(t.defaultValue) && t.defaultValue.length === 0)) || !e.includes(t.columnType), {
+	message: "A default value is not allowed for this column type",
+	path: ["defaultValue"]
+}).transform((e, t) => e.defaultValue == null ? c(e, "defaultValue") : {
+	...e,
+	defaultValue: g(e.defaultValue, a(e.columnType), "defaultValue", t)
+}).transform((e, t) => e.enumValues == null ? c(e, "enumValues") : {
+	...e,
+	enumValues: g(e.enumValues, o(e.columnType), "enumValues", t)
+}), v = u.array(_), y = m.extend({ isSelected: u.boolean() });
+h.extend({
+	isSelected: u.boolean(),
+	isOriginallyDefaultColumn: u.boolean(),
+	jsonSubColumns: u.array(y).optional()
+});
+function b(e) {
+	return v.safeParse(e);
 }
 //#endregion
-export { h as columnModelFormDataZodSchema, m as columnModelZodSchema, f as jsonSubColumnModelZodSchema, _ as validateColumnModelFormData };
+export { v as columnModelFormDataZodSchema, _ as columnModelZodSchema, m as jsonSubColumnModelZodSchema, b as validateColumnModelFormData };
 
 //# sourceMappingURL=ColumnModelValidator.js.map

package/dist/components/TableColumnSchemaEditor/Validators/ColumnModelValidator.js.map

@@ -1 +1 @@
-{"version":3,"file":"ColumnModelValidator.js","names":[],"sources":["../../../../src/components/TableColumnSchemaEditor/Validators/ColumnModelValidator.ts"],"sourcesContent":["import { ColumnModel, ColumnTypeEnum } from '@sage-bionetworks/synapse-types'\nimport {\n  canHaveMaxListLength,\n  canHaveSize,\n  MAX_LIST_LENGTH,\n  MAX_STRING_SIZE,\n} from '../TableColumnSchemaEditorUtils'\nimport { type SafeParseReturnType, z } from 'zod'\nimport { SetOptional } from 'type-fest'\nimport { getDefaultValueValidator } from './DefaultValueValidator'\nimport getEnumValuesValidator from './EnumValuesValidator'\nimport { optionalStringSchema } from './OptionalStringSchema'\nimport { omit } from 'lodash-es'\n\nconst facetTypeSchema = z.union([z.literal('enumeration'), z.literal('range')])\n\nconst facetColumnSortConfigSchema = z.object({\n  property: z.enum(['FREQUENCY', 'VALUE']).optional(),\n  direction: z.enum(['DESC', 'ASC']).optional(),\n})\n\nconst columnModelBaseZodSchema = z.object({\n  name: z.string().min(1, { message: 'Name is required' }),\n  columnType: z.nativeEnum(ColumnTypeEnum),\n})\n\nexport const jsonSubColumnModelZodSchema = columnModelBaseZodSchema.merge(\n  z.object({\n    jsonPath: z.string().startsWith('$'),\n    facetType: facetTypeSchema,\n  }),\n)\n\n/**\n * Zod schema whose shape represents a ColumnModel. This unrefined schema is saved in this \"intermediate\" state so\n * that it can be extended with `.merge` to create an inferred type that can applied to form data.\n */\nconst unrefinedColumnModelSchema = columnModelBaseZodSchema.merge(\n  z.object({\n    id: z.string().optional(),\n    defaultValue: z.union([z.string(), z.array(z.any())]).optional(),\n    maximumSize: z\n      .union([optionalStringSchema, z.number()])\n      .pipe(\n        z.coerce.number().finite().int().min(1).max(MAX_STRING_SIZE).optional(),\n      ),\n    maximumListLength: z\n      .union([optionalStringSchema, z.number()])\n      .pipe(\n        z.coerce.number().finite().int().min(1).max(MAX_LIST_LENGTH).optional(),\n      ),\n    enumValues: z\n      .array(\n        z\n          .union([\n            z.string(),\n            // enumValues is allowed on INTEGER type, but the backend stores them as strings, so allow passing integers\n            z.number().int(),\n          ])\n          .pipe(z.coerce.string()),\n      )\n      .optional(),\n    jsonSubColumns: z.array(jsonSubColumnModelZodSchema).optional(),\n    facetType: facetTypeSchema.optional(),\n    facetSortConfig: facetColumnSortConfigSchema.optional(),\n  }),\n)\n\n/**\n * Zod schema to validate a column model. The provided data is coerced and transformed to match the ColumnModel type.\n * For this reason, form data may be directly passed into this schema parser.\n *\n * The parse method will return a ColumnModel where all data is properly formed.\n */\nexport const columnModelZodSchema = unrefinedColumnModelSchema\n  .refine(data => data.maximumSize == null || canHaveSize(data.columnType), {\n    message: 'Size is not allowed for this column type',\n    path: ['maximumSize'],\n  })\n  .refine(\n    data =>\n      data.maximumListLength == null || canHaveMaxListLength(data.columnType),\n    {\n      message: 'Maximum list length is not allowed for this column type',\n      path: ['maximumListLength'],\n    },\n  )\n  .refine(\n    data => {\n      if (data.jsonSubColumns != null) {\n        return data.columnType === ColumnTypeEnum.JSON\n      }\n      return true\n    },\n    {\n      message: 'Only JSON columns can have JSON sub-columns.',\n      path: ['columnType'],\n    },\n  )\n  .transform((data, ctx) => {\n    if (data.defaultValue != null) {\n      // Validate and transform the defaultValue based on the columnType\n      const defaultValueSchema = getDefaultValueValidator(data.columnType)\n      const result = defaultValueSchema.safeParse(data.defaultValue)\n      let transformedValue: string | undefined\n      if (result.success) {\n        transformedValue = result.data\n      } else {\n        result.error.issues.forEach(issue => {\n          ctx.addIssue({ ...issue, path: ['defaultValue'] })\n        })\n        transformedValue = undefined\n      }\n      return { ...data, defaultValue: transformedValue }\n    }\n    return omit(data, 'defaultValue')\n  })\n  .transform((data, ctx) => {\n    // NOTE: This is the same set of steps as the `defaultValue` transform\n    // We may be able to refactor this, but it is challenging to do so without breaking the schema's inferred type\n    if (data.enumValues != null) {\n      // Validate and transform the defaultValue based on the columnType\n      const enumValuesSchema = getEnumValuesValidator(data.columnType)\n      const result = enumValuesSchema.safeParse(data.enumValues)\n      let transformedValue: string[] | undefined\n      if (result.success) {\n        transformedValue = result.data\n      } else {\n        result.error.issues.forEach(issue => {\n          ctx.addIssue({ ...issue, path: ['enumValues'] })\n        })\n        transformedValue = undefined\n      }\n      return { ...data, enumValues: transformedValue }\n    }\n    return omit(data, 'enumValues')\n  })\n\nexport const columnModelFormDataZodSchema = z.array(columnModelZodSchema)\n\nconst jsonSubColumnModelFormDataSchema = jsonSubColumnModelZodSchema.merge(\n  z.object({\n    isSelected: z.boolean(),\n  }),\n)\n\nexport type JsonSubColumnModelFormData = z.input<\n  typeof jsonSubColumnModelFormDataSchema\n>\n\n// Use the \"unrefined\" schema since we can extend it with form-only fields\nconst _columnModelFormDataSchema = unrefinedColumnModelSchema.merge(\n  z.object({\n    isSelected: z.boolean(),\n    isOriginallyDefaultColumn: z.boolean(),\n    jsonSubColumns: z.array(jsonSubColumnModelFormDataSchema).optional(),\n  }),\n)\n\n/**\n * Type that represents possible form input data for a ColumnModel.\n * a\n */\nexport type ColumnModelFormData = z.input<typeof _columnModelFormDataSchema>\n\nexport function validateColumnModelFormData(\n  formData: SetOptional<\n    ColumnModelFormData,\n    'isOriginallyDefaultColumn' | 'isSelected'\n  >[],\n): SafeParseReturnType<\n  SetOptional<\n    ColumnModelFormData,\n    'isOriginallyDefaultColumn' | 'isSelected'\n  >[],\n  SetOptional<ColumnModel, 'id'>[]\n> {\n  return columnModelFormDataZodSchema.safeParse(formData)\n}\n"],"mappings":"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"}
+{"version":3,"file":"ColumnModelValidator.js","names":[],"sources":["../../../../src/components/TableColumnSchemaEditor/Validators/ColumnModelValidator.ts"],"sourcesContent":["import { ColumnModel, ColumnTypeEnum } from '@sage-bionetworks/synapse-types'\nimport {\n  canHaveMaxListLength,\n  canHaveSize,\n  DISALLOWED_DEFAULT_VALUE_COLUMN_TYPES,\n  getMaxListLengthForType,\n  MAX_COLUMN_NAME_LENGTH,\n  MAX_ENUM_VALUES,\n  MAX_STRING_SIZE,\n} from '../TableColumnSchemaEditorUtils'\nimport { z, ZodType } from 'zod'\nimport { SetOptional } from 'type-fest'\nimport { getDefaultValueValidator } from './DefaultValueValidator'\nimport getEnumValuesValidator from './EnumValuesValidator'\nimport { optionalStringSchema } from './OptionalStringSchema'\nimport { omit } from 'lodash-es'\n\nconst facetTypeSchema = z.enum(['enumeration', 'range'])\n\nconst facetColumnSortConfigSchema = z.object({\n  property: z.enum(['FREQUENCY', 'VALUE']).optional(),\n  direction: z.enum(['DESC', 'ASC']).optional(),\n})\n\nconst columnModelBaseZodSchema = z.object({\n  name: z\n    .string()\n    .min(1, { message: 'Name is required' })\n    .max(MAX_COLUMN_NAME_LENGTH, {\n      message: `Name must be ${MAX_COLUMN_NAME_LENGTH} characters or fewer`,\n    }),\n  columnType: z.enum(ColumnTypeEnum),\n})\n\nexport const jsonSubColumnModelZodSchema = columnModelBaseZodSchema.extend({\n  jsonPath: z.string().startsWith('$'),\n  facetType: facetTypeSchema,\n})\n\n/**\n * Zod schema whose shape represents a ColumnModel. This unrefined schema is saved in this \"intermediate\" state so\n * that it can be extended to create an inferred type that can applied to form data.\n */\nconst unrefinedColumnModelSchema = columnModelBaseZodSchema.extend({\n  id: z.string().optional(),\n  defaultValue: z.union([z.string(), z.array(z.any())]).optional(),\n  maximumSize: z\n    .union([optionalStringSchema, z.number()])\n    // Convert string input to a number before validating\n    .transform(v => (typeof v === 'string' ? Number(v) : v))\n    .pipe(z.number().int().min(1).max(MAX_STRING_SIZE).optional()),\n  maximumListLength: z\n    .union([optionalStringSchema, z.number()])\n    .transform(v => (typeof v === 'string' ? Number(v) : v))\n    .pipe(z.number().int().min(1).optional()),\n  enumValues: z\n    .array(\n      z\n        .union([\n          z.string(),\n          // enumValues is allowed on INTEGER type, but the backend stores them as strings, so allow passing integers\n          z.number().int(),\n        ])\n        .pipe(z.coerce.string()),\n    )\n    .max(MAX_ENUM_VALUES, {\n      message: `A column may have at most ${MAX_ENUM_VALUES} enumeration values`,\n    })\n    .optional(),\n  jsonSubColumns: z.array(jsonSubColumnModelZodSchema).optional(),\n  facetType: facetTypeSchema.optional(),\n  facetSortConfig: facetColumnSortConfigSchema.optional(),\n})\n\n/**\n * Runs a field-specific sub-validator against a value, forwarding any issues to the parent\n * context (re-pathed to `path`). Returns the transformed value, or undefined if validation failed.\n */\nfunction parseSubField<T>(\n  value: unknown,\n  schema: ZodType<T | undefined>,\n  path: string,\n  ctx: z.RefinementCtx,\n): T | undefined {\n  const result = schema.safeParse(value)\n  if (result.success) {\n    return result.data\n  }\n  result.error.issues.forEach(issue => {\n    ctx.addIssue({ ...issue, path: [path] })\n  })\n  return undefined\n}\n\n/**\n * Zod schema to validate a column model. The provided data is coerced and transformed to match the ColumnModel type.\n * For this reason, form data may be directly passed into this schema parser.\n *\n * The parse method will return a ColumnModel where all data is properly formed.\n */\nexport const columnModelZodSchema = unrefinedColumnModelSchema\n  .refine(data => data.maximumSize == null || canHaveSize(data.columnType), {\n    message: 'Size is not allowed for this column type',\n    path: ['maximumSize'],\n  })\n  .refine(\n    data =>\n      data.maximumListLength == null || canHaveMaxListLength(data.columnType),\n    {\n      message: 'Maximum list length is not allowed for this column type',\n      path: ['maximumListLength'],\n    },\n  )\n  .superRefine((data, ctx) => {\n    if (\n      data.maximumListLength == null ||\n      !canHaveMaxListLength(data.columnType)\n    ) {\n      // Either no list length is set, or a previous refinement already rejected it\n      return\n    }\n    const maxListLength = getMaxListLengthForType(\n      data.columnType,\n      data.maximumSize,\n    )\n    if (data.maximumListLength > maxListLength) {\n      ctx.addIssue({\n        code: 'custom',\n        message: `Maximum list length must not exceed ${maxListLength} for this column type and element size`,\n        path: ['maximumListLength'],\n      })\n    }\n  })\n  .refine(\n    data => {\n      if (data.jsonSubColumns != null) {\n        return data.columnType === ColumnTypeEnum.JSON\n      }\n      return true\n    },\n    {\n      message: 'Only JSON columns can have JSON sub-columns.',\n      path: ['columnType'],\n    },\n  )\n  .refine(\n    data => {\n      // An empty string or empty array is treated as \"no default value\" (see the defaultValue transform below)\n      const hasDefaultValue =\n        data.defaultValue != null &&\n        data.defaultValue !== '' &&\n        !(Array.isArray(data.defaultValue) && data.defaultValue.length === 0)\n      return (\n        !hasDefaultValue ||\n        !DISALLOWED_DEFAULT_VALUE_COLUMN_TYPES.includes(data.columnType)\n      )\n    },\n    {\n      message: 'A default value is not allowed for this column type',\n      path: ['defaultValue'],\n    },\n  )\n  .transform((data, ctx) => {\n    // Validate and transform the defaultValue based on the columnType\n    if (data.defaultValue == null) {\n      return omit(data, 'defaultValue')\n    }\n    return {\n      ...data,\n      defaultValue: parseSubField(\n        data.defaultValue,\n        getDefaultValueValidator(data.columnType),\n        'defaultValue',\n        ctx,\n      ),\n    }\n  })\n  .transform((data, ctx) => {\n    // Validate and transform the enumValues based on the columnType\n    if (data.enumValues == null) {\n      return omit(data, 'enumValues')\n    }\n    return {\n      ...data,\n      enumValues: parseSubField(\n        data.enumValues,\n        getEnumValuesValidator(data.columnType),\n        'enumValues',\n        ctx,\n      ),\n    }\n  })\n\nexport const columnModelFormDataZodSchema = z.array(columnModelZodSchema)\n\nconst jsonSubColumnModelFormDataSchema = jsonSubColumnModelZodSchema.extend({\n  isSelected: z.boolean(),\n})\n\nexport type JsonSubColumnModelFormData = z.input<\n  typeof jsonSubColumnModelFormDataSchema\n>\n\n// Use the \"unrefined\" schema since we can extend it with form-only fields\nconst _columnModelFormDataSchema = unrefinedColumnModelSchema.extend({\n  isSelected: z.boolean(),\n  isOriginallyDefaultColumn: z.boolean(),\n  jsonSubColumns: z.array(jsonSubColumnModelFormDataSchema).optional(),\n})\n\n/**\n * Type that represents possible form input data for a ColumnModel.\n * a\n */\nexport type ColumnModelFormData = z.input<typeof _columnModelFormDataSchema>\n\nexport function validateColumnModelFormData(\n  formData: SetOptional<\n    ColumnModelFormData,\n    'isOriginallyDefaultColumn' | 'isSelected'\n  >[],\n): z.ZodSafeParseResult<SetOptional<ColumnModel, 'id'>[]> {\n  return columnModelFormDataZodSchema.safeParse(formData)\n}\n"],"mappings":"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"}

package/dist/components/TableColumnSchemaEditor/Validators/DatetimeSchema.d.ts

@@ -2,5 +2,5 @@ import { z } from 'zod';
 /**
  * Validates and converts a value to a valid Synapse DATE value
  */
-export declare const dateTimeSchema: z.ZodEffects<z.ZodUnion<[z.ZodNumber, z.ZodEffects<z.ZodString, string, string>, z.ZodDate]>, string, string | number | Date>;
+export declare const dateTimeSchema: z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodDate]>, z.ZodTransform<string, string | number | Date>>;
 //# sourceMappingURL=DatetimeSchema.d.ts.map

package/dist/components/TableColumnSchemaEditor/Validators/DatetimeSchema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DatetimeSchema.d.ts","sourceRoot":"","sources":["../../../../src/components/TableColumnSchemaEditor/Validators/DatetimeSchema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAgBvB;;GAEG;AACH,eAAO,MAAM,cAAc,+HAEkC,CAAA"}
+{"version":3,"file":"DatetimeSchema.d.ts","sourceRoot":"","sources":["../../../../src/components/TableColumnSchemaEditor/Validators/DatetimeSchema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAgBvB;;GAEG;AACH,eAAO,MAAM,cAAc,kKAEkC,CAAA"}

package/dist/components/TableColumnSchemaEditor/Validators/DatetimeSchema.js.map

@@ -1 +1 @@
-{"version":3,"file":"DatetimeSchema.js","names":[],"sources":["../../../../src/components/TableColumnSchemaEditor/Validators/DatetimeSchema.ts"],"sourcesContent":["import { z } from 'zod'\nimport dayjs from 'dayjs'\nimport utc from 'dayjs/plugin/utc'\n\ndayjs.extend(utc)\n\n// Accepts a string that is either a UNIX timestamp in milliseconds or in ISO 8601 format, and returns a string in ISO 8601 format\nconst dateTimeString = z.string().transform(data => {\n  // Note: can't use parseInt on a timestamp! \"2000-01-01T00:00:00Z\" will be parsed as 2000\n  const isInt = data.match(/^\\d+$/)\n  if (isInt) {\n    return dayjs.utc(parseInt(data)).toISOString()\n  }\n  return dayjs.utc(data).toISOString()\n})\n\n/**\n * Validates and converts a value to a valid Synapse DATE value\n */\nexport const dateTimeSchema = z\n  .union([z.number(), dateTimeString, z.date()])\n  .transform(timestampMs => dayjs(timestampMs).toISOString())\n"],"mappings":";;;;AAIA,EAAM,OAAO,EAAI;AAGjB,IAAM,IAAiB,EAAE,QAAQ,CAAC,WAAU,MAE5B,EAAK,MAAM,QACrB,GACK,EAAM,IAAI,SAAS,EAAK,CAAC,CAAC,aAAa,GAEzC,EAAM,IAAI,EAAK,CAAC,aAAa,CACpC,EAKW,IAAiB,EAC3B,MAAM;CAAC,EAAE,QAAQ;CAAE;CAAgB,EAAE,MAAM;CAAC,CAAC,CAC7C,WAAU,MAAe,EAAM,EAAY,CAAC,aAAa,CAAC"}
+{"version":3,"file":"DatetimeSchema.js","names":[],"sources":["../../../../src/components/TableColumnSchemaEditor/Validators/DatetimeSchema.ts"],"sourcesContent":["import { z } from 'zod'\nimport dayjs from 'dayjs'\nimport utc from 'dayjs/plugin/utc'\n\ndayjs.extend(utc)\n\n// Accepts a string that is either a UNIX timestamp in milliseconds or in ISO 8601 format, and returns a string in ISO 8601 format\nconst dateTimeString = z.string().transform(data => {\n  // Note: can't use parseInt on a timestamp! \"2000-01-01T00:00:00Z\" will be parsed as 2000\n  const isInt = data.match(/^\\d+$/)\n  if (isInt) {\n    return dayjs.utc(parseInt(data)).toISOString()\n  }\n  return dayjs.utc(data).toISOString()\n})\n\n/**\n * Validates and converts a value to a valid Synapse DATE value\n */\nexport const dateTimeSchema = z\n  .union([z.number(), dateTimeString, z.date()])\n  .transform(timestampMs => dayjs(timestampMs).toISOString())\n"],"mappings":";;;;AAIA,EAAM,OAAO,CAAG;AAGhB,IAAM,IAAiB,EAAE,OAAO,EAAE,WAAU,MAE5B,EAAK,MAAM,OACrB,IACK,EAAM,IAAI,SAAS,CAAI,CAAC,EAAE,YAAY,IAExC,EAAM,IAAI,CAAI,EAAE,YAAY,CACpC,GAKY,IAAiB,EAC3B,MAAM;CAAC,EAAE,OAAO;CAAG;CAAgB,EAAE,KAAK;AAAC,CAAC,EAC5C,WAAU,MAAe,EAAM,CAAW,EAAE,YAAY,CAAC"}

package/dist/components/TableColumnSchemaEditor/Validators/DefaultValueValidator.js.map

@@ -1 +1 @@
-{"version":3,"file":"DefaultValueValidator.js","names":[],"sources":["../../../../src/components/TableColumnSchemaEditor/Validators/DefaultValueValidator.ts"],"sourcesContent":["import { ColumnTypeEnum } from '@sage-bionetworks/synapse-types'\nimport { z, ZodType } from 'zod'\nimport { isArray, isEmpty } from 'lodash-es'\nimport getZodSchemaForColumnType from './getZodSchemaForColumnType'\n\n/**\n * Returns a validator for a ColumnModel's `defaultValue` field.\n * This validator will transform the field to match the correct type of defaultValue, which is an optional string.\n * @param columnType the columnType of the ColumnModel\n */\nexport function getDefaultValueValidator(\n  columnType: ColumnTypeEnum,\n): ZodType<string | undefined> {\n  const schema = getZodSchemaForColumnType(columnType)\n  return z\n    .union([\n      z.null(),\n      z\n        .string()\n        .length(0)\n        .transform(() => null),\n      schema,\n    ])\n    .optional()\n    .refine(data => {\n      if (columnType.endsWith('_LIST')) {\n        return data == null || isArray(data)\n      }\n      return true\n    }, 'Default value cannot be an array for a non-list column type')\n    .transform(data => {\n      if (data == null || data === '' || (isArray(data) && isEmpty(data))) {\n        return undefined\n      } else if (typeof data === 'string') {\n        return data\n      } else {\n        return JSON.stringify(data)\n      }\n    })\n}\n"],"mappings":";;;;AAUA,SAAgB,EACd,GAC6B;CAC7B,IAAM,IAAS,EAA0B,EAAW;AACpD,QAAO,EACJ,MAAM;EACL,EAAE,MAAM;EACR,EACG,QAAQ,CACR,OAAO,EAAE,CACT,gBAAgB,KAAK;EACxB;EACD,CAAC,CACD,UAAU,CACV,QAAO,MACF,EAAW,SAAS,QAAQ,GACvB,KAAQ,QAAQ,EAAQ,EAAK,GAE/B,IACN,8DAA8D,CAChE,WAAU,MAAQ;AACb,aAAQ,QAAQ,MAAS,MAAO,EAAQ,EAAK,IAAI,EAAQ,EAAK,EAKhE,QAHS,OAAO,KAAS,WAClB,IAEA,KAAK,UAAU,EAAK;GAE7B"}
+{"version":3,"file":"DefaultValueValidator.js","names":[],"sources":["../../../../src/components/TableColumnSchemaEditor/Validators/DefaultValueValidator.ts"],"sourcesContent":["import { ColumnTypeEnum } from '@sage-bionetworks/synapse-types'\nimport { z, ZodType } from 'zod'\nimport { isArray, isEmpty } from 'lodash-es'\nimport getZodSchemaForColumnType from './getZodSchemaForColumnType'\n\n/**\n * Returns a validator for a ColumnModel's `defaultValue` field.\n * This validator will transform the field to match the correct type of defaultValue, which is an optional string.\n * @param columnType the columnType of the ColumnModel\n */\nexport function getDefaultValueValidator(\n  columnType: ColumnTypeEnum,\n): ZodType<string | undefined> {\n  const schema = getZodSchemaForColumnType(columnType)\n  return z\n    .union([\n      z.null(),\n      z\n        .string()\n        .length(0)\n        .transform(() => null),\n      schema,\n    ])\n    .optional()\n    .refine(data => {\n      if (columnType.endsWith('_LIST')) {\n        return data == null || isArray(data)\n      }\n      return true\n    }, 'Default value cannot be an array for a non-list column type')\n    .transform(data => {\n      if (data == null || data === '' || (isArray(data) && isEmpty(data))) {\n        return undefined\n      } else if (typeof data === 'string') {\n        return data\n      } else {\n        return JSON.stringify(data)\n      }\n    })\n}\n"],"mappings":";;;;AAUA,SAAgB,EACd,GAC6B;CAC7B,IAAM,IAAS,EAA0B,CAAU;CACnD,OAAO,EACJ,MAAM;EACL,EAAE,KAAK;EACP,EACG,OAAO,EACP,OAAO,CAAC,EACR,gBAAgB,IAAI;EACvB;CACF,CAAC,EACA,SAAS,EACT,QAAO,MACF,EAAW,SAAS,OAAO,IACtB,KAAQ,QAAQ,EAAQ,CAAI,IAE9B,IACN,6DAA6D,EAC/D,WAAU,MAAQ;EACb,WAAQ,QAAQ,MAAS,MAAO,EAAQ,CAAI,KAAK,EAAQ,CAAI,IAK/D,OAHS,OAAO,KAAS,WAClB,IAEA,KAAK,UAAU,CAAI;CAE9B,CAAC;AACL"}

package/dist/components/TableColumnSchemaEditor/Validators/DoubleSchema.d.ts

@@ -2,5 +2,5 @@ import { z } from 'zod';
 /**
  * Validates and converts a value to a valid Synapse DOUBLE value. Zod will return an error if the value cannot be converted to a number.
  */
-export declare const doubleSchema: z.ZodEffects<z.ZodUnion<[z.ZodNumber, z.ZodNaN, z.ZodEffects<z.ZodString, string | number, string>]>, string | number, string | number>;
+export declare const doubleSchema: z.ZodPipe<z.ZodUnion<readonly [z.ZodCustom<number, number>, z.ZodPipe<z.ZodString, z.ZodTransform<string | number, string>>]>, z.ZodTransform<string | number, string | number>>;
 //# sourceMappingURL=DoubleSchema.d.ts.map

package/dist/components/TableColumnSchemaEditor/Validators/DoubleSchema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DoubleSchema.d.ts","sourceRoot":"","sources":["../../../../src/components/TableColumnSchemaEditor/Validators/DoubleSchema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAwBvB;;GAEG;AACH,eAAO,MAAM,YAAY,yIAerB,CAAA"}
+{"version":3,"file":"DoubleSchema.d.ts","sourceRoot":"","sources":["../../../../src/components/TableColumnSchemaEditor/Validators/DoubleSchema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AA4BvB;;GAEG;AACH,eAAO,MAAM,YAAY,kLAiBrB,CAAA"}

package/dist/components/TableColumnSchemaEditor/Validators/DoubleSchema.js

@@ -1,25 +1,18 @@
 import { z as e } from "zod";
 //#region src/components/TableColumnSchemaEditor/Validators/DoubleSchema.ts
-var t = e.string().transform((t, n) => {
+var t = e.custom((e) => typeof e == "number"), n = e.string().transform((t, n) => {
 	if ([
 		"NaN",
 		"Infinity",
 		"-Infinity"
 	].includes(t)) return t;
 	let r = Number(t);
-	return isNaN(r) && n.addIssue({
-		code: e.ZodIssueCode.invalid_type,
-		expected: "number",
-		received: "string",
-		path: [],
+	return isNaN(r) ? (n.addIssue({
+		code: "custom",
 		message: "Must be a number"
-	}), r;
-}), n = e.union([
-	e.number(),
-	e.nan(),
-	t
-]).transform((e) => typeof e == "number" ? isNaN(e) ? "NaN" : e === Infinity ? "Infinity" : e === -Infinity ? "-Infinity" : e : e);
+	}), e.NEVER) : r;
+}), r = e.union([t, n]).transform((e) => typeof e == "number" ? isNaN(e) ? "NaN" : e === Infinity ? "Infinity" : e === -Infinity ? "-Infinity" : e : e);
 //#endregion
-export { n as doubleSchema };
+export { r as doubleSchema };
 
 //# sourceMappingURL=DoubleSchema.js.map

package/dist/components/TableColumnSchemaEditor/Validators/DoubleSchema.js.map

@@ -1 +1 @@
-{"version":3,"file":"DoubleSchema.js","names":[],"sources":["../../../../src/components/TableColumnSchemaEditor/Validators/DoubleSchema.ts"],"sourcesContent":["import { z } from 'zod'\n\n/**\n * Schema that converts strings to valid Synapse DOUBLE values. Zod will return an error if the string cannot be parsed as a number.\n */\nconst doubleString = z.string().transform((data, ctx) => {\n  // Synapse permits NaN/Infinity, so we can keep these strings\n  if (['NaN', 'Infinity', '-Infinity'].includes(data)) {\n    return data\n  }\n  const parsed = Number(data)\n  // If the parse result is NaN, then this was not a valid number\n  if (isNaN(parsed)) {\n    ctx.addIssue({\n      code: z.ZodIssueCode.invalid_type,\n      expected: 'number',\n      received: 'string',\n      path: [],\n      message: 'Must be a number',\n    })\n  }\n  return parsed\n})\n\n/**\n * Validates and converts a value to a valid Synapse DOUBLE value. Zod will return an error if the value cannot be converted to a number.\n */\nexport const doubleSchema = z\n  .union([z.number(), z.nan(), doubleString])\n  .transform((val): string | number => {\n    if (typeof val === 'number') {\n      // JSON does not support NaN/Infinity, but Synapse does if they are strings\n      if (isNaN(val)) {\n        return 'NaN'\n      } else if (val === Infinity) {\n        return 'Infinity'\n      } else if (val === -Infinity) {\n        return '-Infinity'\n      }\n      return val\n    }\n    return val\n  })\n"],"mappings":";;AAKA,IAAM,IAAe,EAAE,QAAQ,CAAC,WAAW,GAAM,MAAQ;AAEvD,KAAI;EAAC;EAAO;EAAY;EAAY,CAAC,SAAS,EAAK,CACjD,QAAO;CAET,IAAM,IAAS,OAAO,EAAK;AAW3B,QATI,MAAM,EAAO,IACf,EAAI,SAAS;EACX,MAAM,EAAE,aAAa;EACrB,UAAU;EACV,UAAU;EACV,MAAM,EAAE;EACR,SAAS;EACV,CAAC,EAEG;EACP,EAKW,IAAe,EACzB,MAAM;CAAC,EAAE,QAAQ;CAAE,EAAE,KAAK;CAAE;CAAa,CAAC,CAC1C,WAAW,MACN,OAAO,KAAQ,WAEb,MAAM,EAAI,GACL,QACE,MAAQ,WACV,aACE,MAAQ,YACV,cAEF,IAEF,EACP"}
+{"version":3,"file":"DoubleSchema.js","names":[],"sources":["../../../../src/components/TableColumnSchemaEditor/Validators/DoubleSchema.ts"],"sourcesContent":["import { z } from 'zod'\n\n/**\n * Accepts any JavaScript number, including NaN and +/-Infinity. In zod 4, `z.number()`\n * only accepts finite values, but Synapse DOUBLE columns support NaN and +/- Infinity (as strings).\n */\nconst anyNumberSchema = z.custom<number>(val => typeof val === 'number')\n\n/**\n * Schema that converts strings to valid Synapse DOUBLE values. Zod will return an error if the string cannot be parsed as a number.\n */\nconst doubleString = z.string().transform((data, ctx) => {\n  // Synapse permits NaN/Infinity, so we can keep these strings\n  if (['NaN', 'Infinity', '-Infinity'].includes(data)) {\n    return data\n  }\n  const parsed = Number(data)\n  // If the parse result is NaN, then this was not a valid number\n  if (isNaN(parsed)) {\n    ctx.addIssue({\n      code: 'custom',\n      message: 'Must be a number',\n    })\n    return z.NEVER\n  }\n  return parsed\n})\n\n/**\n * Validates and converts a value to a valid Synapse DOUBLE value. Zod will return an error if the value cannot be converted to a number.\n */\nexport const doubleSchema = z\n  .union([anyNumberSchema, doubleString])\n  .transform((val): string | number => {\n    // JSON does not support NaN/Infinity, but Synapse does if they are strings\n    if (typeof val !== 'number') {\n      return val\n    }\n    if (isNaN(val)) {\n      return 'NaN'\n    }\n    if (val === Infinity) {\n      return 'Infinity'\n    }\n    if (val === -Infinity) {\n      return '-Infinity'\n    }\n    return val\n  })\n"],"mappings":";;AAMA,IAAM,IAAkB,EAAE,QAAe,MAAO,OAAO,KAAQ,QAAQ,GAKjE,IAAe,EAAE,OAAO,EAAE,WAAW,GAAM,MAAQ;CAEvD,IAAI;EAAC;EAAO;EAAY;CAAW,EAAE,SAAS,CAAI,GAChD,OAAO;CAET,IAAM,IAAS,OAAO,CAAI;CAS1B,OAPI,MAAM,CAAM,KACd,EAAI,SAAS;EACX,MAAM;EACN,SAAS;CACX,CAAC,GACM,EAAE,SAEJ;AACT,CAAC,GAKY,IAAe,EACzB,MAAM,CAAC,GAAiB,CAAY,CAAC,EACrC,WAAW,MAEN,OAAO,KAAQ,WAGf,MAAM,CAAG,IACJ,QAEL,MAAQ,WACH,aAEL,MAAQ,YACH,cAEF,IAXE,CAYV"}

package/dist/components/TableColumnSchemaEditor/Validators/EntityIdSchema.d.ts

@@ -2,5 +2,5 @@ import { z } from 'zod';
 /**
  * Validates and converts a value to a valid Synapse ENTITYID value
  */
-export declare const entityIdSchema: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+export declare const entityIdSchema: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
 //# sourceMappingURL=EntityIdSchema.d.ts.map

package/dist/components/TableColumnSchemaEditor/Validators/EntityIdSchema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"EntityIdSchema.d.ts","sourceRoot":"","sources":["../../../../src/components/TableColumnSchemaEditor/Validators/EntityIdSchema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB;;GAEG;AACH,eAAO,MAAM,cAAc,wCAIzB,CAAA"}
+{"version":3,"file":"EntityIdSchema.d.ts","sourceRoot":"","sources":["../../../../src/components/TableColumnSchemaEditor/Validators/EntityIdSchema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB;;GAEG;AACH,eAAO,MAAM,cAAc,iDAIzB,CAAA"}

package/dist/components/TableColumnSchemaEditor/Validators/EntityIdSchema.js.map

@@ -1 +1 @@
-{"version":3,"file":"EntityIdSchema.js","names":[],"sources":["../../../../src/components/TableColumnSchemaEditor/Validators/EntityIdSchema.ts"],"sourcesContent":["import { z } from 'zod'\n\n/**\n * Validates and converts a value to a valid Synapse ENTITYID value\n */\nexport const entityIdSchema = z.union([\n  // Matches a string of digits, optionally prefixed with 'syn'\n  z.string().regex(/^(syn)?\\d+$/),\n  z.number().int(),\n])\n"],"mappings":";;AAKA,IAAa,IAAiB,EAAE,MAAM,CAEpC,EAAE,QAAQ,CAAC,MAAM,cAAc,EAC/B,EAAE,QAAQ,CAAC,KAAK,CACjB,CAAC"}
+{"version":3,"file":"EntityIdSchema.js","names":[],"sources":["../../../../src/components/TableColumnSchemaEditor/Validators/EntityIdSchema.ts"],"sourcesContent":["import { z } from 'zod'\n\n/**\n * Validates and converts a value to a valid Synapse ENTITYID value\n */\nexport const entityIdSchema = z.union([\n  // Matches a string of digits, optionally prefixed with 'syn'\n  z.string().regex(/^(syn)?\\d+$/),\n  z.number().int(),\n])\n"],"mappings":";;AAKA,IAAa,IAAiB,EAAE,MAAM,CAEpC,EAAE,OAAO,EAAE,MAAM,aAAa,GAC9B,EAAE,OAAO,EAAE,IAAI,CACjB,CAAC"}

package/dist/components/TableColumnSchemaEditor/Validators/EnumValuesValidator.js.map

@@ -1 +1 @@
-{"version":3,"file":"EnumValuesValidator.js","names":[],"sources":["../../../../src/components/TableColumnSchemaEditor/Validators/EnumValuesValidator.ts"],"sourcesContent":["import { ColumnTypeEnum } from '@sage-bionetworks/synapse-types'\nimport { z, ZodType } from 'zod'\nimport { isEmpty } from 'lodash-es'\nimport getZodSchemaForColumnType from './getZodSchemaForColumnType'\n\n/**\n * Returns a validator for a ColumnModel's `enumValues` field.\n * This validator will transform the field to match the correct type of defaultValue, which is an optional array of strings.\n * @param columnType the columnType of the ColumnModel\n */\nexport default function getEnumValuesValidator(\n  columnType: ColumnTypeEnum,\n): ZodType<string[] | undefined> {\n  const schema = getZodSchemaForColumnType(columnType)\n  return z\n    .union([\n      z.array(schema),\n      z.null(),\n      z\n        .string()\n        .length(0)\n        .transform(() => null),\n      schema.transform(v => [v]),\n    ])\n    .optional()\n    .transform(data => {\n      if (data == null) {\n        return undefined\n      }\n      // Remove empty strings and null values\n      data = data.filter(v => v !== '' && v != null)\n      if (isEmpty(data)) {\n        return undefined\n      }\n\n      // Each value must be converted to a string\n      return data.map(v => (typeof v === 'string' ? v : JSON.stringify(v)))\n    })\n}\n"],"mappings":";;;;AAUA,SAAwB,EACtB,GAC+B;CAC/B,IAAM,IAAS,EAA0B,EAAW;AACpD,QAAO,EACJ,MAAM;EACL,EAAE,MAAM,EAAO;EACf,EAAE,MAAM;EACR,EACG,QAAQ,CACR,OAAO,EAAE,CACT,gBAAgB,KAAK;EACxB,EAAO,WAAU,MAAK,CAAC,EAAE,CAAC;EAC3B,CAAC,CACD,UAAU,CACV,WAAU,MAAQ;AACb,WAAQ,SAIZ,IAAO,EAAK,QAAO,MAAK,MAAM,MAAM,KAAK,KAAK,EAC1C,GAAQ,EAAK,EAKjB,QAAO,EAAK,KAAI,MAAM,OAAO,KAAM,WAAW,IAAI,KAAK,UAAU,EAAE,CAAE;GACrE"}
+{"version":3,"file":"EnumValuesValidator.js","names":[],"sources":["../../../../src/components/TableColumnSchemaEditor/Validators/EnumValuesValidator.ts"],"sourcesContent":["import { ColumnTypeEnum } from '@sage-bionetworks/synapse-types'\nimport { z, ZodType } from 'zod'\nimport { isEmpty } from 'lodash-es'\nimport getZodSchemaForColumnType from './getZodSchemaForColumnType'\n\n/**\n * Returns a validator for a ColumnModel's `enumValues` field.\n * This validator will transform the field to match the correct type of defaultValue, which is an optional array of strings.\n * @param columnType the columnType of the ColumnModel\n */\nexport default function getEnumValuesValidator(\n  columnType: ColumnTypeEnum,\n): ZodType<string[] | undefined> {\n  const schema = getZodSchemaForColumnType(columnType)\n  return z\n    .union([\n      z.array(schema),\n      z.null(),\n      z\n        .string()\n        .length(0)\n        .transform(() => null),\n      schema.transform(v => [v]),\n    ])\n    .optional()\n    .transform(data => {\n      if (data == null) {\n        return undefined\n      }\n      // Remove empty strings and null values\n      data = data.filter(v => v !== '' && v != null)\n      if (isEmpty(data)) {\n        return undefined\n      }\n\n      // Each value must be converted to a string\n      return data.map(v => (typeof v === 'string' ? v : JSON.stringify(v)))\n    })\n}\n"],"mappings":";;;;AAUA,SAAwB,EACtB,GAC+B;CAC/B,IAAM,IAAS,EAA0B,CAAU;CACnD,OAAO,EACJ,MAAM;EACL,EAAE,MAAM,CAAM;EACd,EAAE,KAAK;EACP,EACG,OAAO,EACP,OAAO,CAAC,EACR,gBAAgB,IAAI;EACvB,EAAO,WAAU,MAAK,CAAC,CAAC,CAAC;CAC3B,CAAC,EACA,SAAS,EACT,WAAU,MAAQ;EACb,SAAQ,SAIZ,IAAO,EAAK,QAAO,MAAK,MAAM,MAAM,KAAK,IAAI,GACzC,GAAQ,CAAI,IAKhB,OAAO,EAAK,KAAI,MAAM,OAAO,KAAM,WAAW,IAAI,KAAK,UAAU,CAAC,CAAE;CACtE,CAAC;AACL"}

package/dist/components/TableColumnSchemaEditor/Validators/IntegerSchema.d.ts

@@ -2,5 +2,5 @@ import { z } from 'zod';
 /**
  * Validates and converts a value to a valid Synapse INTEGER value
  */
-export declare const integerSchema: z.ZodPipeline<z.ZodUnion<[z.ZodEffects<z.ZodString, string | null, string>, z.ZodNull, z.ZodNumber]>, z.ZodUnion<[z.ZodNull, z.ZodNumber]>>;
+export declare const integerSchema: z.ZodPipe<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<number | null, string>>, z.ZodNull, z.ZodNumber]>, z.ZodUnion<readonly [z.ZodNull, z.ZodNumber]>>;
 //# sourceMappingURL=IntegerSchema.d.ts.map

package/dist/components/TableColumnSchemaEditor/Validators/IntegerSchema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"IntegerSchema.d.ts","sourceRoot":"","sources":["../../../../src/components/TableColumnSchemaEditor/Validators/IntegerSchema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB;;GAEG;AACH,eAAO,MAAM,aAAa,6IAS2B,CAAA"}
+{"version":3,"file":"IntegerSchema.d.ts","sourceRoot":"","sources":["../../../../src/components/TableColumnSchemaEditor/Validators/IntegerSchema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB;;GAEG;AACH,eAAO,MAAM,aAAa,wKASoB,CAAA"}

package/dist/components/TableColumnSchemaEditor/Validators/IntegerSchema.js

@@ -1,10 +1,10 @@
 import { z as e } from "zod";
 //#region src/components/TableColumnSchemaEditor/Validators/IntegerSchema.ts
 var t = e.union([
-	e.string().transform((e) => e === "" ? null : e),
+	e.string().transform((e) => e === "" ? null : Number(e)),
 	e.null(),
 	e.number().int()
-]).pipe(e.union([e.null(), e.coerce.number().int()]));
+]).pipe(e.union([e.null(), e.number().int()]));
 //#endregion
 export { t as integerSchema };
 

package/dist/components/TableColumnSchemaEditor/Validators/IntegerSchema.js.map

@@ -1 +1 @@
-{"version":3,"file":"IntegerSchema.js","names":[],"sources":["../../../../src/components/TableColumnSchemaEditor/Validators/IntegerSchema.ts"],"sourcesContent":["import { z } from 'zod'\n\n/**\n * Validates and converts a value to a valid Synapse INTEGER value\n */\nexport const integerSchema = z\n  .union([\n    z\n      .string()\n      // Transform empty string to null\n      .transform(data => (data === '' ? null : data)),\n    z.null(),\n    z.number().int(),\n  ])\n  .pipe(z.union([z.null(), z.coerce.number().int()]))\n"],"mappings":";;AAKA,IAAa,IAAgB,EAC1B,MAAM;CACL,EACG,QAAQ,CAER,WAAU,MAAS,MAAS,KAAK,OAAO,EAAM;CACjD,EAAE,MAAM;CACR,EAAE,QAAQ,CAAC,KAAK;CACjB,CAAC,CACD,KAAK,EAAE,MAAM,CAAC,EAAE,MAAM,EAAE,EAAE,OAAO,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC"}
+{"version":3,"file":"IntegerSchema.js","names":[],"sources":["../../../../src/components/TableColumnSchemaEditor/Validators/IntegerSchema.ts"],"sourcesContent":["import { z } from 'zod'\n\n/**\n * Validates and converts a value to a valid Synapse INTEGER value\n */\nexport const integerSchema = z\n  .union([\n    z\n      .string()\n      // Transform empty string to null, otherwise convert to a number\n      .transform(data => (data === '' ? null : Number(data))),\n    z.null(),\n    z.number().int(),\n  ])\n  .pipe(z.union([z.null(), z.number().int()]))\n"],"mappings":";;AAKA,IAAa,IAAgB,EAC1B,MAAM;CACL,EACG,OAAO,EAEP,WAAU,MAAS,MAAS,KAAK,OAAO,OAAO,CAAI,CAAE;CACxD,EAAE,KAAK;CACP,EAAE,OAAO,EAAE,IAAI;AACjB,CAAC,EACA,KAAK,EAAE,MAAM,CAAC,EAAE,KAAK,GAAG,EAAE,OAAO,EAAE,IAAI,CAAC,CAAC,CAAC"}

package/dist/components/TableColumnSchemaEditor/Validators/OptionalStringSchema.d.ts

@@ -2,5 +2,5 @@ import { z } from 'zod';
 /**
  * Schema for an optional string. Converts empty string to undefined.
  */
-export declare const optionalStringSchema: z.ZodEffects<z.ZodOptional<z.ZodString>, string | undefined, string | undefined>;
+export declare const optionalStringSchema: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, string | undefined>>;
 //# sourceMappingURL=OptionalStringSchema.d.ts.map

package/dist/components/TableColumnSchemaEditor/Validators/OptionalStringSchema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"OptionalStringSchema.d.ts","sourceRoot":"","sources":["../../../../src/components/TableColumnSchemaEditor/Validators/OptionalStringSchema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB;;GAEG;AACH,eAAO,MAAM,oBAAoB,kFAGY,CAAA"}
+{"version":3,"file":"OptionalStringSchema.d.ts","sourceRoot":"","sources":["../../../../src/components/TableColumnSchemaEditor/Validators/OptionalStringSchema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB;;GAEG;AACH,eAAO,MAAM,oBAAoB,+FAGY,CAAA"}

package/dist/components/TableColumnSchemaEditor/Validators/OptionalStringSchema.js.map

@@ -1 +1 @@
-{"version":3,"file":"OptionalStringSchema.js","names":[],"sources":["../../../../src/components/TableColumnSchemaEditor/Validators/OptionalStringSchema.ts"],"sourcesContent":["import { z } from 'zod'\n\n/**\n * Schema for an optional string. Converts empty string to undefined.\n */\nexport const optionalStringSchema = z\n  .string()\n  .optional()\n  .transform(v => (v === '' ? undefined : v))\n"],"mappings":";;AAKA,IAAa,IAAuB,EACjC,QAAQ,CACR,UAAU,CACV,WAAU,MAAM,MAAM,KAAK,KAAA,IAAY,EAAG"}
+{"version":3,"file":"OptionalStringSchema.js","names":[],"sources":["../../../../src/components/TableColumnSchemaEditor/Validators/OptionalStringSchema.ts"],"sourcesContent":["import { z } from 'zod'\n\n/**\n * Schema for an optional string. Converts empty string to undefined.\n */\nexport const optionalStringSchema = z\n  .string()\n  .optional()\n  .transform(v => (v === '' ? undefined : v))\n"],"mappings":";;AAKA,IAAa,IAAuB,EACjC,OAAO,EACP,SAAS,EACT,WAAU,MAAM,MAAM,KAAK,KAAA,IAAY,CAAE"}

package/dist/components/TableColumnSchemaEditor/Validators/getZodSchemaForColumnType.d.ts

@@ -1,4 +1,4 @@
 import { ColumnTypeEnum } from '@sage-bionetworks/synapse-types';
-import { ZodTypeAny } from 'zod';
-export default function getZodSchemaForColumnType(columnType: ColumnTypeEnum): ZodTypeAny;
+import { ZodType } from 'zod';
+export default function getZodSchemaForColumnType(columnType: ColumnTypeEnum): ZodType;
 //# sourceMappingURL=getZodSchemaForColumnType.d.ts.map

package/dist/components/TableColumnSchemaEditor/Validators/getZodSchemaForColumnType.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getZodSchemaForColumnType.d.ts","sourceRoot":"","sources":["../../../../src/components/TableColumnSchemaEditor/Validators/getZodSchemaForColumnType.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAA;AAEhE,OAAO,EAAK,UAAU,EAAE,MAAM,KAAK,CAAA;AAyBnC,MAAM,CAAC,OAAO,UAAU,yBAAyB,CAC/C,UAAU,EAAE,cAAc,GACzB,UAAU,CAoDZ"}
+{"version":3,"file":"getZodSchemaForColumnType.d.ts","sourceRoot":"","sources":["../../../../src/components/TableColumnSchemaEditor/Validators/getZodSchemaForColumnType.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAA;AAEhE,OAAO,EAAK,OAAO,EAAE,MAAM,KAAK,CAAA;AA0BhC,MAAM,CAAC,OAAO,UAAU,yBAAyB,CAC/C,UAAU,EAAE,cAAc,GACzB,OAAO,CA6CT"}

package/dist/components/TableColumnSchemaEditor/Validators/getZodSchemaForColumnType.js

@@ -9,17 +9,16 @@ import { z as o } from "zod";
 var s = o.string().transform((e, t) => {
 	try {
 		let n = JSON.parse(e);
-		return Array.isArray(n) || t.addIssue({
-			code: o.ZodIssueCode.custom,
+		return Array.isArray(n) ? n : (t.addIssue({
+			code: "custom",
 			message: "Object was valid JSON, but was not an array"
-		}), n;
+		}), o.NEVER);
 	} catch {
-		t.addIssue({
-			code: o.ZodIssueCode.custom,
+		return t.addIssue({
+			code: "custom",
 			message: "Invalid JSON array"
-		});
+		}), o.NEVER;
 	}
-	return e;
 });
 function c(l) {
 	if (l.endsWith("_LIST")) {
@@ -27,19 +26,19 @@ function c(l) {
 		return o.union([o.array(e), s.pipe(o.array(e))]);
 	}
 	switch (l) {
-		case a.STRING: return o.coerce.string();
+		case a.STRING:
+		case a.LINK:
+		case a.MEDIUMTEXT:
+		case a.LARGETEXT: return o.coerce.string();
 		case a.BOOLEAN: return n;
-		case a.INTEGER: return r;
+		case a.INTEGER:
+		case a.FILEHANDLEID:
+		case a.USERID:
+		case a.EVALUATIONID:
+		case a.SUBMISSIONID: return r;
 		case a.DOUBLE: return e;
 		case a.DATE: return t;
-		case a.FILEHANDLEID: return r;
 		case a.ENTITYID: return i;
-		case a.LINK: return o.coerce.string();
-		case a.MEDIUMTEXT: return o.coerce.string();
-		case a.LARGETEXT: return o.coerce.string();
-		case a.USERID: return r;
-		case a.EVALUATIONID: return r;
-		case a.SUBMISSIONID: return r;
 		case a.JSON: return o.string().refine((e) => {
 			try {
 				return JSON.parse(e), !0;

package/dist/components/TableColumnSchemaEditor/Validators/getZodSchemaForColumnType.js.map

@@ -1 +1 @@
-{"version":3,"file":"getZodSchemaForColumnType.js","names":[],"sources":["../../../../src/components/TableColumnSchemaEditor/Validators/getZodSchemaForColumnType.ts"],"sourcesContent":["import { ColumnTypeEnum } from '@sage-bionetworks/synapse-types'\nimport { doubleSchema } from './DoubleSchema'\nimport { z, ZodTypeAny } from 'zod'\nimport { dateTimeSchema } from './DatetimeSchema'\nimport { booleanSchema } from './BooleanSchema'\nimport { integerSchema } from './IntegerSchema'\nimport { entityIdSchema } from './EntityIdSchema'\n\nconst arraySerializedAsStringSchema = z.string().transform((data, ctx) => {\n  try {\n    const parsed = JSON.parse(data)\n    if (!Array.isArray(parsed)) {\n      ctx.addIssue({\n        code: z.ZodIssueCode.custom,\n        message: 'Object was valid JSON, but was not an array',\n      })\n    }\n    return parsed\n  } catch (e) {\n    ctx.addIssue({\n      code: z.ZodIssueCode.custom,\n      message: 'Invalid JSON array',\n    })\n  }\n  return data\n})\n\nexport default function getZodSchemaForColumnType(\n  columnType: ColumnTypeEnum,\n): ZodTypeAny {\n  if (columnType.endsWith('_LIST')) {\n    const baseSchema = getZodSchemaForColumnType(\n      columnType.replace('_LIST', '') as ColumnTypeEnum,\n    )\n    return z.union([\n      z.array(baseSchema),\n      // Also handle cases where the array is serialized as a string\n      arraySerializedAsStringSchema.pipe(z.array(baseSchema)),\n    ])\n  }\n\n  switch (columnType) {\n    case ColumnTypeEnum.STRING:\n      return z.coerce.string()\n    case ColumnTypeEnum.BOOLEAN:\n      return booleanSchema\n    case ColumnTypeEnum.INTEGER:\n      return integerSchema\n    case ColumnTypeEnum.DOUBLE:\n      return doubleSchema\n    case ColumnTypeEnum.DATE:\n      return dateTimeSchema\n    case ColumnTypeEnum.FILEHANDLEID:\n      return integerSchema\n    case ColumnTypeEnum.ENTITYID:\n      return entityIdSchema\n    case ColumnTypeEnum.LINK:\n      return z.coerce.string()\n    case ColumnTypeEnum.MEDIUMTEXT:\n      return z.coerce.string()\n    case ColumnTypeEnum.LARGETEXT:\n      return z.coerce.string()\n    case ColumnTypeEnum.USERID:\n      return integerSchema\n    case ColumnTypeEnum.EVALUATIONID:\n      return integerSchema\n    case ColumnTypeEnum.SUBMISSIONID:\n      return integerSchema\n    case ColumnTypeEnum.JSON:\n      return z.string().refine(v => {\n        try {\n          JSON.parse(v)\n          return true\n        } catch (e) {\n          return false\n        }\n      })\n    default:\n      console.warn(`No validator for column type ${columnType}`)\n      return z.any()\n  }\n}\n"],"mappings":";;;;;;;;AAQA,IAAM,IAAgC,EAAE,QAAQ,CAAC,WAAW,GAAM,MAAQ;AACxE,KAAI;EACF,IAAM,IAAS,KAAK,MAAM,EAAK;AAO/B,SANK,MAAM,QAAQ,EAAO,IACxB,EAAI,SAAS;GACX,MAAM,EAAE,aAAa;GACrB,SAAS;GACV,CAAC,EAEG;SACG;AACV,IAAI,SAAS;GACX,MAAM,EAAE,aAAa;GACrB,SAAS;GACV,CAAC;;AAEJ,QAAO;EACP;AAEF,SAAwB,EACtB,GACY;AACZ,KAAI,EAAW,SAAS,QAAQ,EAAE;EAChC,IAAM,IAAa,EACjB,EAAW,QAAQ,SAAS,GAAG,CAChC;AACD,SAAO,EAAE,MAAM,CACb,EAAE,MAAM,EAAW,EAEnB,EAA8B,KAAK,EAAE,MAAM,EAAW,CAAC,CACxD,CAAC;;AAGJ,SAAQ,GAAR;EACE,KAAK,EAAe,OAClB,QAAO,EAAE,OAAO,QAAQ;EAC1B,KAAK,EAAe,QAClB,QAAO;EACT,KAAK,EAAe,QAClB,QAAO;EACT,KAAK,EAAe,OAClB,QAAO;EACT,KAAK,EAAe,KAClB,QAAO;EACT,KAAK,EAAe,aAClB,QAAO;EACT,KAAK,EAAe,SAClB,QAAO;EACT,KAAK,EAAe,KAClB,QAAO,EAAE,OAAO,QAAQ;EAC1B,KAAK,EAAe,WAClB,QAAO,EAAE,OAAO,QAAQ;EAC1B,KAAK,EAAe,UAClB,QAAO,EAAE,OAAO,QAAQ;EAC1B,KAAK,EAAe,OAClB,QAAO;EACT,KAAK,EAAe,aAClB,QAAO;EACT,KAAK,EAAe,aAClB,QAAO;EACT,KAAK,EAAe,KAClB,QAAO,EAAE,QAAQ,CAAC,QAAO,MAAK;AAC5B,OAAI;AAEF,WADA,KAAK,MAAM,EAAE,EACN;WACG;AACV,WAAO;;IAET;EACJ,QAEE,QADA,QAAQ,KAAK,gCAAgC,IAAa,EACnD,EAAE,KAAK"}
+{"version":3,"file":"getZodSchemaForColumnType.js","names":[],"sources":["../../../../src/components/TableColumnSchemaEditor/Validators/getZodSchemaForColumnType.ts"],"sourcesContent":["import { ColumnTypeEnum } from '@sage-bionetworks/synapse-types'\nimport { doubleSchema } from './DoubleSchema'\nimport { z, ZodType } from 'zod'\nimport { dateTimeSchema } from './DatetimeSchema'\nimport { booleanSchema } from './BooleanSchema'\nimport { integerSchema } from './IntegerSchema'\nimport { entityIdSchema } from './EntityIdSchema'\n\nconst arraySerializedAsStringSchema = z.string().transform((data, ctx) => {\n  try {\n    const parsed = JSON.parse(data)\n    if (!Array.isArray(parsed)) {\n      ctx.addIssue({\n        code: 'custom',\n        message: 'Object was valid JSON, but was not an array',\n      })\n      return z.NEVER\n    }\n    return parsed\n  } catch (e) {\n    ctx.addIssue({\n      code: 'custom',\n      message: 'Invalid JSON array',\n    })\n    return z.NEVER\n  }\n})\n\nexport default function getZodSchemaForColumnType(\n  columnType: ColumnTypeEnum,\n): ZodType {\n  if (columnType.endsWith('_LIST')) {\n    const baseSchema = getZodSchemaForColumnType(\n      columnType.replace('_LIST', '') as ColumnTypeEnum,\n    )\n    return z.union([\n      z.array(baseSchema),\n      // Also handle cases where the array is serialized as a string\n      arraySerializedAsStringSchema.pipe(z.array(baseSchema)),\n    ])\n  }\n\n  switch (columnType) {\n    case ColumnTypeEnum.STRING:\n    case ColumnTypeEnum.LINK:\n    case ColumnTypeEnum.MEDIUMTEXT:\n    case ColumnTypeEnum.LARGETEXT:\n      return z.coerce.string()\n    case ColumnTypeEnum.BOOLEAN:\n      return booleanSchema\n    case ColumnTypeEnum.INTEGER:\n    case ColumnTypeEnum.FILEHANDLEID:\n    case ColumnTypeEnum.USERID:\n    case ColumnTypeEnum.EVALUATIONID:\n    case ColumnTypeEnum.SUBMISSIONID:\n      return integerSchema\n    case ColumnTypeEnum.DOUBLE:\n      return doubleSchema\n    case ColumnTypeEnum.DATE:\n      return dateTimeSchema\n    case ColumnTypeEnum.ENTITYID:\n      return entityIdSchema\n    case ColumnTypeEnum.JSON:\n      return z.string().refine(v => {\n        try {\n          JSON.parse(v)\n          return true\n        } catch (e) {\n          return false\n        }\n      })\n    default:\n      console.warn(`No validator for column type ${columnType}`)\n      return z.any()\n  }\n}\n"],"mappings":";;;;;;;;AAQA,IAAM,IAAgC,EAAE,OAAO,EAAE,WAAW,GAAM,MAAQ;CACxE,IAAI;EACF,IAAM,IAAS,KAAK,MAAM,CAAI;EAQ9B,OAPK,MAAM,QAAQ,CAAM,IAOlB,KANL,EAAI,SAAS;GACX,MAAM;GACN,SAAS;EACX,CAAC,GACM,EAAE;CAGb,QAAY;EAKV,OAJA,EAAI,SAAS;GACX,MAAM;GACN,SAAS;EACX,CAAC,GACM,EAAE;CACX;AACF,CAAC;AAED,SAAwB,EACtB,GACS;CACT,IAAI,EAAW,SAAS,OAAO,GAAG;EAChC,IAAM,IAAa,EACjB,EAAW,QAAQ,SAAS,EAAE,CAChC;EACA,OAAO,EAAE,MAAM,CACb,EAAE,MAAM,CAAU,GAElB,EAA8B,KAAK,EAAE,MAAM,CAAU,CAAC,CACxD,CAAC;CACH;CAEA,QAAQ,GAAR;EACE,KAAK,EAAe;EACpB,KAAK,EAAe;EACpB,KAAK,EAAe;EACpB,KAAK,EAAe,WAClB,OAAO,EAAE,OAAO,OAAO;EACzB,KAAK,EAAe,SAClB,OAAO;EACT,KAAK,EAAe;EACpB,KAAK,EAAe;EACpB,KAAK,EAAe;EACpB,KAAK,EAAe;EACpB,KAAK,EAAe,cAClB,OAAO;EACT,KAAK,EAAe,QAClB,OAAO;EACT,KAAK,EAAe,MAClB,OAAO;EACT,KAAK,EAAe,UAClB,OAAO;EACT,KAAK,EAAe,MAClB,OAAO,EAAE,OAAO,EAAE,QAAO,MAAK;GAC5B,IAAI;IAEF,OADA,KAAK,MAAM,CAAC,GACL;GACT,QAAY;IACV,OAAO;GACT;EACF,CAAC;EACH,SAEE,OADA,QAAQ,KAAK,gCAAgC,GAAY,GAClD,EAAE,IAAI;CACjB;AACF"}

package/dist/components/TableFeedCards/TableFeedCards.js.map

@@ -1 +1 @@
-{"version":3,"file":"TableFeedCards.js","names":[],"sources":["../../../src/components/TableFeedCards/TableFeedCards.tsx"],"sourcesContent":["import LargeButton from '@/components/styled/LargeButton'\nimport SynapseClient from '@/synapse-client'\nimport { SynapseConstants } from '@/utils'\nimport { useSynapseContext } from '@/utils/context/SynapseContext'\nimport {\n  QueryBundleRequest,\n  RowSet,\n  SelectColumn,\n} from '@sage-bionetworks/synapse-types'\nimport dayjs from 'dayjs'\nimport { useEffect, useState } from 'react'\nimport loadingScreen from '../LoadingScreen/LoadingScreen'\nimport MarkdownSynapse from '../Markdown/MarkdownSynapse'\n\nexport type TableFeedCardsProps = {\n  tableEntityId: string\n}\n\nfunction TableFeedCards({ tableEntityId }: TableFeedCardsProps) {\n  const { accessToken } = useSynapseContext()\n  const [rowSet, setRowSet] = useState<RowSet>()\n  const [itemCountShowing, setItemCountShowing] = useState<number>(3)\n\n  let mounted = true\n  useEffect(() => {\n    const executeQuery = () => {\n      if (mounted) {\n        if (rowSet) {\n          return\n        }\n        const request: QueryBundleRequest = {\n          concreteType:\n            'org.sagebionetworks.repo.model.table.QueryBundleRequest',\n          query: {\n            sql: `SELECT \"categories\", \"date\", \"title\", \"mdDescription\" FROM ${tableEntityId} ORDER BY \"date\" desc`,\n          },\n          entityId: tableEntityId,\n          partMask: SynapseConstants.BUNDLE_MASK_QUERY_RESULTS,\n        }\n        SynapseClient.getQueryTableResults(request, accessToken).then(data => {\n          setRowSet(data.queryResult?.queryResults)\n        })\n      }\n    }\n    executeQuery()\n    return () => {\n      mounted = false\n    }\n  }, [tableEntityId, accessToken])\n\n  if (!rowSet) {\n    return loadingScreen\n  }\n  const headers: SelectColumn[] = rowSet.headers\n  const categoriesColIndex = headers.findIndex(col => col.name === 'categories')\n  const dateColIndex = headers.findIndex(col => col.name === 'date')\n  const titleColIndex = headers.findIndex(col => col.name === 'title')\n  const descriptionColIndex = headers.findIndex(\n    col => col.name === 'mdDescription',\n  )\n\n  return (\n    <div className=\"Feed\">\n      <div className=\"FeedItems\">\n        {rowSet.rows.map((row, index) => {\n          if (index > itemCountShowing - 1) {\n            return\n          }\n          const values = row.values as string[]\n          if (values.some(value => value === null)) {\n            console.warn('Row has null value(s) when no nulls expected')\n          }\n          const categoriesList = JSON.parse(values[categoriesColIndex])\n          const dateStringTimestamp = values[dateColIndex]\n          const title = values[titleColIndex]\n          const description = values[descriptionColIndex]\n\n          return (\n            <div className=\"FeedItem\" key={`row-${index}`}>\n              <div>\n                {categoriesList && (\n                  <div className=\"FeedItemCategories\">\n                    {(categoriesList as string[]).map(\n                      (categoryName: string, categoryIndex) => {\n                        return (\n                          <div\n                            key={`row-${index},categoryIndex-${categoryIndex}`}\n                            className=\"FeedItemCategory\"\n                          >\n                            {categoryName}\n                          </div>\n                        )\n                      },\n                    )}\n                  </div>\n                )}\n                <p className=\"FeedItemDate\">\n                  {dayjs(new Date(parseInt(dateStringTimestamp))).format(\n                    'MMMM YYYY',\n                  )}\n                </p>\n                <p className=\"FeedItemTitle\">{title}</p>\n                <div className=\"FeedItemDescription\">\n                  <MarkdownSynapse markdown={description} />\n                </div>\n              </div>\n            </div>\n          )\n        })}\n      </div>\n      {rowSet.rows.length > itemCountShowing && (\n        <div className=\"FeedViewAllNewsButtonContainer\">\n          <LargeButton\n            color=\"primary\"\n            variant=\"contained\"\n            onClick={() => setItemCountShowing(itemCountShowing + 3)}\n          >\n            View More News\n          </LargeButton>\n        </div>\n      )}\n    </div>\n  )\n}\nexport default TableFeedCards\n"],"mappings":";;;;;;;;;;;AAkBA,SAAS,EAAe,EAAE,oBAAsC;CAC9D,IAAM,EAAE,mBAAgB,GAAmB,EACrC,CAAC,GAAQ,KAAa,GAAkB,EACxC,CAAC,GAAkB,KAAuB,EAAiB,EAAE,EAE/D,IAAU;AA2Bd,KA1BA,gBAC6B;AACzB,MAAI,GAAS;AACX,OAAI,EACF;GAEF,IAAM,IAA8B;IAClC,cACE;IACF,OAAO,EACL,KAAK,8DAA8D,EAAc,wBAClF;IACD,UAAU;IACV,UAAU;IACX;AACD,KAAc,qBAAqB,GAAS,EAAY,CAAC,MAAK,MAAQ;AACpE,MAAU,EAAK,aAAa,aAAa;KACzC;;KAGQ,QACD;AACX,MAAU;KAEX,CAAC,GAAe,EAAY,CAAC,EAE5B,CAAC,EACH,QAAO;CAET,IAAM,IAA0B,EAAO,SACjC,IAAqB,EAAQ,WAAU,MAAO,EAAI,SAAS,aAAa,EACxE,IAAe,EAAQ,WAAU,MAAO,EAAI,SAAS,OAAO,EAC5D,IAAgB,EAAQ,WAAU,MAAO,EAAI,SAAS,QAAQ,EAC9D,IAAsB,EAAQ,WAClC,MAAO,EAAI,SAAS,gBACrB;AAED,QACE,kBAAC,OAAD;EAAK,WAAU;YAAf,CACE,kBAAC,OAAD;GAAK,WAAU;aACZ,EAAO,KAAK,KAAK,GAAK,MAAU;AAC/B,QAAI,IAAQ,IAAmB,EAC7B;IAEF,IAAM,IAAS,EAAI;AACnB,IAAI,EAAO,MAAK,MAAS,MAAU,KAAK,IACtC,QAAQ,KAAK,+CAA+C;IAE9D,IAAM,IAAiB,KAAK,MAAM,EAAO,GAAoB,EACvD,IAAsB,EAAO,IAC7B,IAAQ,EAAO,IACf,IAAc,EAAO;AAE3B,WACE,kBAAC,OAAD;KAAK,WAAU;eACb,kBAAC,OAAD,EAAA,UAAA;MACG,KACC,kBAAC,OAAD;OAAK,WAAU;iBACX,EAA4B,KAC3B,GAAsB,MAEnB,kBAAC,OAAD;QAEE,WAAU;kBAET;QACG,EAJC,OAAO,EAAM,iBAAiB,IAI/B,CAGX;OACG,CAAA;MAER,kBAAC,KAAD;OAAG,WAAU;iBACV,EAAM,IAAI,KAAK,SAAS,EAAoB,CAAC,CAAC,CAAC,OAC9C,YACD;OACC,CAAA;MACJ,kBAAC,KAAD;OAAG,WAAU;iBAAiB;OAAU,CAAA;MACxC,kBAAC,OAAD;OAAK,WAAU;iBACb,kBAAC,GAAD,EAAiB,UAAU,GAAe,CAAA;OACtC,CAAA;MACF,EAAA,CAAA;KACF,EA5ByB,OAAO,IA4BhC;KAER;GACE,CAAA,EACL,EAAO,KAAK,SAAS,KACpB,kBAAC,OAAD;GAAK,WAAU;aACb,kBAAC,GAAD;IACE,OAAM;IACN,SAAQ;IACR,eAAe,EAAoB,IAAmB,EAAE;cACzD;IAEa,CAAA;GACV,CAAA,CAEJ"}
+{"version":3,"file":"TableFeedCards.js","names":[],"sources":["../../../src/components/TableFeedCards/TableFeedCards.tsx"],"sourcesContent":["import LargeButton from '@/components/styled/LargeButton'\nimport SynapseClient from '@/synapse-client'\nimport { SynapseConstants } from '@/utils'\nimport { useSynapseContext } from '@/utils/context/SynapseContext'\nimport {\n  QueryBundleRequest,\n  RowSet,\n  SelectColumn,\n} from '@sage-bionetworks/synapse-types'\nimport dayjs from 'dayjs'\nimport { useEffect, useState } from 'react'\nimport loadingScreen from '../LoadingScreen/LoadingScreen'\nimport MarkdownSynapse from '../Markdown/MarkdownSynapse'\n\nexport type TableFeedCardsProps = {\n  tableEntityId: string\n}\n\nfunction TableFeedCards({ tableEntityId }: TableFeedCardsProps) {\n  const { accessToken } = useSynapseContext()\n  const [rowSet, setRowSet] = useState<RowSet>()\n  const [itemCountShowing, setItemCountShowing] = useState<number>(3)\n\n  let mounted = true\n  useEffect(() => {\n    const executeQuery = () => {\n      if (mounted) {\n        if (rowSet) {\n          return\n        }\n        const request: QueryBundleRequest = {\n          concreteType:\n            'org.sagebionetworks.repo.model.table.QueryBundleRequest',\n          query: {\n            sql: `SELECT \"categories\", \"date\", \"title\", \"mdDescription\" FROM ${tableEntityId} ORDER BY \"date\" desc`,\n          },\n          entityId: tableEntityId,\n          partMask: SynapseConstants.BUNDLE_MASK_QUERY_RESULTS,\n        }\n        SynapseClient.getQueryTableResults(request, accessToken).then(data => {\n          setRowSet(data.queryResult?.queryResults)\n        })\n      }\n    }\n    executeQuery()\n    return () => {\n      mounted = false\n    }\n  }, [tableEntityId, accessToken])\n\n  if (!rowSet) {\n    return loadingScreen\n  }\n  const headers: SelectColumn[] = rowSet.headers\n  const categoriesColIndex = headers.findIndex(col => col.name === 'categories')\n  const dateColIndex = headers.findIndex(col => col.name === 'date')\n  const titleColIndex = headers.findIndex(col => col.name === 'title')\n  const descriptionColIndex = headers.findIndex(\n    col => col.name === 'mdDescription',\n  )\n\n  return (\n    <div className=\"Feed\">\n      <div className=\"FeedItems\">\n        {rowSet.rows.map((row, index) => {\n          if (index > itemCountShowing - 1) {\n            return\n          }\n          const values = row.values as string[]\n          if (values.some(value => value === null)) {\n            console.warn('Row has null value(s) when no nulls expected')\n          }\n          const categoriesList = JSON.parse(values[categoriesColIndex])\n          const dateStringTimestamp = values[dateColIndex]\n          const title = values[titleColIndex]\n          const description = values[descriptionColIndex]\n\n          return (\n            <div className=\"FeedItem\" key={`row-${index}`}>\n              <div>\n                {categoriesList && (\n                  <div className=\"FeedItemCategories\">\n                    {(categoriesList as string[]).map(\n                      (categoryName: string, categoryIndex) => {\n                        return (\n                          <div\n                            key={`row-${index},categoryIndex-${categoryIndex}`}\n                            className=\"FeedItemCategory\"\n                          >\n                            {categoryName}\n                          </div>\n                        )\n                      },\n                    )}\n                  </div>\n                )}\n                <p className=\"FeedItemDate\">\n                  {dayjs(new Date(parseInt(dateStringTimestamp))).format(\n                    'MMMM YYYY',\n                  )}\n                </p>\n                <p className=\"FeedItemTitle\">{title}</p>\n                <div className=\"FeedItemDescription\">\n                  <MarkdownSynapse markdown={description} />\n                </div>\n              </div>\n            </div>\n          )\n        })}\n      </div>\n      {rowSet.rows.length > itemCountShowing && (\n        <div className=\"FeedViewAllNewsButtonContainer\">\n          <LargeButton\n            color=\"primary\"\n            variant=\"contained\"\n            onClick={() => setItemCountShowing(itemCountShowing + 3)}\n          >\n            View More News\n          </LargeButton>\n        </div>\n      )}\n    </div>\n  )\n}\nexport default TableFeedCards\n"],"mappings":";;;;;;;;;;;AAkBA,SAAS,EAAe,EAAE,oBAAsC;CAC9D,IAAM,EAAE,mBAAgB,EAAkB,GACpC,CAAC,GAAQ,KAAa,EAAiB,GACvC,CAAC,GAAkB,KAAuB,EAAiB,CAAC,GAE9D,IAAU;CA2Bd,IA1BA,gBAC6B;EACzB,IAAI,GAAS;GACX,IAAI,GACF;GAEF,IAAM,IAA8B;IAClC,cACE;IACF,OAAO,EACL,KAAK,8DAA8D,EAAc,uBACnF;IACA,UAAU;IACV,UAAU;GACZ;GACA,EAAc,qBAAqB,GAAS,CAAW,EAAE,MAAK,MAAQ;IACpE,EAAU,EAAK,aAAa,YAAY;GAC1C,CAAC;EACH;CACF,GACa,SACA;EACX,IAAU;CACZ,IACC,CAAC,GAAe,CAAW,CAAC,GAE3B,CAAC,GACH,OAAO;CAET,IAAM,IAA0B,EAAO,SACjC,IAAqB,EAAQ,WAAU,MAAO,EAAI,SAAS,YAAY,GACvE,IAAe,EAAQ,WAAU,MAAO,EAAI,SAAS,MAAM,GAC3D,IAAgB,EAAQ,WAAU,MAAO,EAAI,SAAS,OAAO,GAC7D,IAAsB,EAAQ,WAClC,MAAO,EAAI,SAAS,eACtB;CAEA,OACE,kBAAC,OAAD;EAAK,WAAU;YAAf,CACE,kBAAC,OAAD;GAAK,WAAU;aACZ,EAAO,KAAK,KAAK,GAAK,MAAU;IAC/B,IAAI,IAAQ,IAAmB,GAC7B;IAEF,IAAM,IAAS,EAAI;IACnB,AAAI,EAAO,MAAK,MAAS,MAAU,IAAI,KACrC,QAAQ,KAAK,8CAA8C;IAE7D,IAAM,IAAiB,KAAK,MAAM,EAAO,EAAmB,GACtD,IAAsB,EAAO,IAC7B,IAAQ,EAAO,IACf,IAAc,EAAO;IAE3B,OACE,kBAAC,OAAD;KAAK,WAAU;eACb,kBAAC,OAAD,EAAA,UAAA;MACG,KACC,kBAAC,OAAD;OAAK,WAAU;iBACX,EAA4B,KAC3B,GAAsB,MAEnB,kBAAC,OAAD;QAEE,WAAU;kBAET;OACE,GAJE,OAAO,EAAM,iBAAiB,GAIhC,CAGX;MACG,CAAA;MAEP,kBAAC,KAAD;OAAG,WAAU;iBACV,EAAM,IAAI,KAAK,SAAS,CAAmB,CAAC,CAAC,EAAE,OAC9C,WACF;MACC,CAAA;MACH,kBAAC,KAAD;OAAG,WAAU;iBAAiB;MAAS,CAAA;MACvC,kBAAC,OAAD;OAAK,WAAU;iBACb,kBAAC,GAAD,EAAiB,UAAU,EAAc,CAAA;MACtC,CAAA;KACF,EAAA,CAAA;IACF,GA5B0B,OAAO,GA4BjC;GAET,CAAC;EACE,CAAA,GACJ,EAAO,KAAK,SAAS,KACpB,kBAAC,OAAD;GAAK,WAAU;aACb,kBAAC,GAAD;IACE,OAAM;IACN,SAAQ;IACR,eAAe,EAAoB,IAAmB,CAAC;cACxD;GAEY,CAAA;EACV,CAAA,CAEJ;;AAET"}

package/dist/components/TanStackTable/ColumnHeader.js.map

@@ -1 +1 @@
-{"version":3,"file":"ColumnHeader.js","names":[],"sources":["../../../src/components/TanStackTable/ColumnHeader.tsx"],"sourcesContent":["import { HeaderContext } from '@tanstack/react-table'\nimport { Box, IconButton, Tooltip } from '@mui/material'\nimport { HelpTwoTone } from '@mui/icons-material'\nimport IconSvg from '../IconSvg'\nimport { ReactNode, useCallback } from 'react'\nimport { ColumnHeaderEnumFilter } from './ColumnHeaderEnumFilter'\n\ntype ColumnHeaderProps = {\n  title?: string\n  helpText?: ReactNode\n  additionalButtons?: ReactNode\n  wrap?: boolean\n\n  // TODO: Replace with props that can be passed to a reusable filter control\n  filterControl?: ReactNode\n}\n\n/**\n * Styled table column header component for use with @tanstack/react-table, with extra optional props for additional\n * UI features\n */\nexport default function ColumnHeader<TData = unknown, TValue = unknown>(\n  props: ColumnHeaderProps & HeaderContext<TData, TValue>,\n) {\n  const {\n    column,\n    title = props.column.id,\n    wrap = false,\n    helpText,\n    filterControl: filterControlFromProps,\n    additionalButtons,\n  } = props\n\n  const getFilterControl = useCallback(() => {\n    if (filterControlFromProps) {\n      return filterControlFromProps\n    }\n    if (column.getCanFilter()) {\n      if (column.columnDef.meta?.filterVariant === 'enumeration') {\n        return <ColumnHeaderEnumFilter column={column} title={title} />\n      }\n      // As needed, extend ColumnMeta.filterVariant to support other types of filters\n      console.warn(\n        `column.getCanFilter() was true for column ID: ${column.id} but no filterControlFromProps was passed and component for filterVariant: ${column.columnDef.meta?.filterVariant} is not implemented`,\n      )\n    }\n    return <></>\n  }, [column, filterControlFromProps, title])\n\n  const filterControl = getFilterControl()\n\n  return (\n    <Box\n      sx={{\n        display: 'flex',\n        alignContent: 'center',\n        alignItems: 'center',\n        justifyContent: 'space-between',\n        overflow: 'hidden',\n        minWidth: 0,\n      }}\n    >\n      <span\n        style={{\n          overflow: 'hidden',\n          textOverflow: 'ellipsis',\n          whiteSpace: wrap ? 'pre-wrap' : 'nowrap',\n          minWidth: 0,\n        }}\n        title={title}\n      >\n        {title}\n      </span>\n      <Box\n        role={'menubar'}\n        sx={{\n          display: 'flex',\n          alignItems: 'center',\n          height: '22px',\n          ml: 2,\n          gap: 0.25,\n        }}\n      >\n        {helpText && (\n          <Tooltip title={helpText} placement={'top'}>\n            <IconButton size={'small'}>\n              <HelpTwoTone fontSize={'inherit'} />\n            </IconButton>\n          </Tooltip>\n        )}\n        {column.getCanFilter() && filterControl}\n        {column.getCanSort() && (\n          <Tooltip title={`Sort by ${title}`} placement={'top'}>\n            <IconButton\n              role=\"button\"\n              size={'small'}\n              aria-label={`Sort by ${title}`}\n              tabIndex={0}\n              onKeyPress={() => column.toggleSorting()}\n              onClick={() => column.toggleSorting()}\n            >\n              <IconSvg\n                icon={column.getIsSorted() === 'asc' ? 'sortUp' : 'sortDown'}\n                wrap={false}\n                sx={{\n                  color: column.getIsSorted() ? 'primary.main' : 'grey.700',\n                  backgroundColor: 'none',\n                }}\n              />\n            </IconButton>\n          </Tooltip>\n        )}\n        {additionalButtons}\n      </Box>\n    </Box>\n  )\n}\n"],"mappings":";;;;;;;AAqBA,SAAwB,EACtB,GACA;CACA,IAAM,EACJ,WACA,WAAQ,EAAM,OAAO,IACrB,UAAO,IACP,aACA,eAAe,GACf,yBACE,GAkBE,IAhBmB,QAAkB;AACzC,MAAI,EACF,QAAO;AAET,MAAI,EAAO,cAAc,EAAE;AACzB,OAAI,EAAO,UAAU,MAAM,kBAAkB,cAC3C,QAAO,kBAAC,GAAD;IAAgC;IAAe;IAAS,CAAA;AAGjE,WAAQ,KACN,iDAAiD,EAAO,GAAG,6EAA6E,EAAO,UAAU,MAAM,cAAc,qBAC9K;;AAEH,SAAO,kBAAA,GAAA,EAAK,CAAA;IACX;EAAC;EAAQ;EAAwB;EAAM,CAEpB,EAAkB;AAExC,QACE,kBAAC,GAAD;EACE,IAAI;GACF,SAAS;GACT,cAAc;GACd,YAAY;GACZ,gBAAgB;GAChB,UAAU;GACV,UAAU;GACX;YARH,CAUE,kBAAC,QAAD;GACE,OAAO;IACL,UAAU;IACV,cAAc;IACd,YAAY,IAAO,aAAa;IAChC,UAAU;IACX;GACM;aAEN;GACI,CAAA,EACP,kBAAC,GAAD;GACE,MAAM;GACN,IAAI;IACF,SAAS;IACT,YAAY;IACZ,QAAQ;IACR,IAAI;IACJ,KAAK;IACN;aARH;IAUG,KACC,kBAAC,GAAD;KAAS,OAAO;KAAU,WAAW;eACnC,kBAAC,GAAD;MAAY,MAAM;gBAChB,kBAAC,GAAD,EAAa,UAAU,WAAa,CAAA;MACzB,CAAA;KACL,CAAA;IAEX,EAAO,cAAc,IAAI;IACzB,EAAO,YAAY,IAClB,kBAAC,GAAD;KAAS,OAAO,WAAW;KAAS,WAAW;eAC7C,kBAAC,GAAD;MACE,MAAK;MACL,MAAM;MACN,cAAY,WAAW;MACvB,UAAU;MACV,kBAAkB,EAAO,eAAe;MACxC,eAAe,EAAO,eAAe;gBAErC,kBAAC,GAAD;OACE,MAAM,EAAO,aAAa,KAAK,QAAQ,WAAW;OAClD,MAAM;OACN,IAAI;QACF,OAAO,EAAO,aAAa,GAAG,iBAAiB;QAC/C,iBAAiB;QAClB;OACD,CAAA;MACS,CAAA;KACL,CAAA;IAEX;IACG;KACF"}
+{"version":3,"file":"ColumnHeader.js","names":[],"sources":["../../../src/components/TanStackTable/ColumnHeader.tsx"],"sourcesContent":["import { HeaderContext } from '@tanstack/react-table'\nimport { Box, IconButton, Tooltip } from '@mui/material'\nimport { HelpTwoTone } from '@mui/icons-material'\nimport IconSvg from '../IconSvg'\nimport { ReactNode, useCallback } from 'react'\nimport { ColumnHeaderEnumFilter } from './ColumnHeaderEnumFilter'\n\ntype ColumnHeaderProps = {\n  title?: string\n  helpText?: ReactNode\n  additionalButtons?: ReactNode\n  wrap?: boolean\n\n  // TODO: Replace with props that can be passed to a reusable filter control\n  filterControl?: ReactNode\n}\n\n/**\n * Styled table column header component for use with @tanstack/react-table, with extra optional props for additional\n * UI features\n */\nexport default function ColumnHeader<TData = unknown, TValue = unknown>(\n  props: ColumnHeaderProps & HeaderContext<TData, TValue>,\n) {\n  const {\n    column,\n    title = props.column.id,\n    wrap = false,\n    helpText,\n    filterControl: filterControlFromProps,\n    additionalButtons,\n  } = props\n\n  const getFilterControl = useCallback(() => {\n    if (filterControlFromProps) {\n      return filterControlFromProps\n    }\n    if (column.getCanFilter()) {\n      if (column.columnDef.meta?.filterVariant === 'enumeration') {\n        return <ColumnHeaderEnumFilter column={column} title={title} />\n      }\n      // As needed, extend ColumnMeta.filterVariant to support other types of filters\n      console.warn(\n        `column.getCanFilter() was true for column ID: ${column.id} but no filterControlFromProps was passed and component for filterVariant: ${column.columnDef.meta?.filterVariant} is not implemented`,\n      )\n    }\n    return <></>\n  }, [column, filterControlFromProps, title])\n\n  const filterControl = getFilterControl()\n\n  return (\n    <Box\n      sx={{\n        display: 'flex',\n        alignContent: 'center',\n        alignItems: 'center',\n        justifyContent: 'space-between',\n        overflow: 'hidden',\n        minWidth: 0,\n      }}\n    >\n      <span\n        style={{\n          overflow: 'hidden',\n          textOverflow: 'ellipsis',\n          whiteSpace: wrap ? 'pre-wrap' : 'nowrap',\n          minWidth: 0,\n        }}\n        title={title}\n      >\n        {title}\n      </span>\n      <Box\n        role={'menubar'}\n        sx={{\n          display: 'flex',\n          alignItems: 'center',\n          height: '22px',\n          ml: 2,\n          gap: 0.25,\n        }}\n      >\n        {helpText && (\n          <Tooltip title={helpText} placement={'top'}>\n            <IconButton size={'small'}>\n              <HelpTwoTone fontSize={'inherit'} />\n            </IconButton>\n          </Tooltip>\n        )}\n        {column.getCanFilter() && filterControl}\n        {column.getCanSort() && (\n          <Tooltip title={`Sort by ${title}`} placement={'top'}>\n            <IconButton\n              role=\"button\"\n              size={'small'}\n              aria-label={`Sort by ${title}`}\n              tabIndex={0}\n              onKeyPress={() => column.toggleSorting()}\n              onClick={() => column.toggleSorting()}\n            >\n              <IconSvg\n                icon={column.getIsSorted() === 'asc' ? 'sortUp' : 'sortDown'}\n                wrap={false}\n                sx={{\n                  color: column.getIsSorted() ? 'primary.main' : 'grey.700',\n                  backgroundColor: 'none',\n                }}\n              />\n            </IconButton>\n          </Tooltip>\n        )}\n        {additionalButtons}\n      </Box>\n    </Box>\n  )\n}\n"],"mappings":";;;;;;;AAqBA,SAAwB,EACtB,GACA;CACA,IAAM,EACJ,WACA,WAAQ,EAAM,OAAO,IACrB,UAAO,IACP,aACA,eAAe,GACf,yBACE,GAkBE,IAhBmB,QAAkB;EACzC,IAAI,GACF,OAAO;EAET,IAAI,EAAO,aAAa,GAAG;GACzB,IAAI,EAAO,UAAU,MAAM,kBAAkB,eAC3C,OAAO,kBAAC,GAAD;IAAgC;IAAe;GAAQ,CAAA;GAGhE,QAAQ,KACN,iDAAiD,EAAO,GAAG,6EAA6E,EAAO,UAAU,MAAM,cAAc,oBAC/K;EACF;EACA,OAAO,kBAAA,GAAA,CAAI,CAAA;CACb,GAAG;EAAC;EAAQ;EAAwB;CAAK,CAEnB,EAAiB;CAEvC,OACE,kBAAC,GAAD;EACE,IAAI;GACF,SAAS;GACT,cAAc;GACd,YAAY;GACZ,gBAAgB;GAChB,UAAU;GACV,UAAU;EACZ;YARF,CAUE,kBAAC,QAAD;GACE,OAAO;IACL,UAAU;IACV,cAAc;IACd,YAAY,IAAO,aAAa;IAChC,UAAU;GACZ;GACO;aAEN;EACG,CAAA,GACN,kBAAC,GAAD;GACE,MAAM;GACN,IAAI;IACF,SAAS;IACT,YAAY;IACZ,QAAQ;IACR,IAAI;IACJ,KAAK;GACP;aARF;IAUG,KACC,kBAAC,GAAD;KAAS,OAAO;KAAU,WAAW;eACnC,kBAAC,GAAD;MAAY,MAAM;gBAChB,kBAAC,GAAD,EAAa,UAAU,UAAY,CAAA;KACzB,CAAA;IACL,CAAA;IAEV,EAAO,aAAa,KAAK;IACzB,EAAO,WAAW,KACjB,kBAAC,GAAD;KAAS,OAAO,WAAW;KAAS,WAAW;eAC7C,kBAAC,GAAD;MACE,MAAK;MACL,MAAM;MACN,cAAY,WAAW;MACvB,UAAU;MACV,kBAAkB,EAAO,cAAc;MACvC,eAAe,EAAO,cAAc;gBAEpC,kBAAC,GAAD;OACE,MAAM,EAAO,YAAY,MAAM,QAAQ,WAAW;OAClD,MAAM;OACN,IAAI;QACF,OAAO,EAAO,YAAY,IAAI,iBAAiB;QAC/C,iBAAiB;OACnB;MACD,CAAA;KACS,CAAA;IACL,CAAA;IAEV;GACE;IACF;;AAET"}