synapse-react-client 4.0.20 → 4.0.22

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":";;;;;;;;AAiBA,IAAM,IAAkB,EAAE,KAAK,CAAC,eAAe,OAAO,CAAC,GAEjD,IAA8B,EAAE,OAAO;CAC3C,UAAU,EAAE,KAAK,CAAC,aAAa,OAAO,CAAC,EAAE,SAAS;CAClD,WAAW,EAAE,KAAK,CAAC,QAAQ,KAAK,CAAC,EAAE,SAAS;AAC9C,CAAC,GAEK,IAA2B,EAAE,OAAO;CACxC,MAAM,EACH,OAAO,EACP,IAAI,GAAG,EAAE,SAAS,mBAAmB,CAAC,EACtC,IAAA,KAA4B,EAC3B,SAAS,uCACX,CAAC;CACH,YAAY,EAAE,KAAK,CAAc;AACnC,CAAC,GAEY,IAA8B,EAAyB,OAAO;CACzE,UAAU,EAAE,OAAO,EAAE,WAAW,GAAG;CACnC,WAAW;AACb,CAAC,GAMK,IAA6B,EAAyB,OAAO;CACjE,IAAI,EAAE,OAAO,EAAE,SAAS;CACxB,cAAc,EAAE,MAAM,CAAC,EAAE,OAAO,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,CAAC,CAAC,EAAE,SAAS;CAC/D,aAAa,EACV,MAAM,CAAC,GAAsB,EAAE,OAAO,CAAC,CAAC,EAExC,WAAU,MAAM,OAAO,KAAM,WAAW,OAAO,CAAC,IAAI,CAAE,EACtD,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,IAAI,CAAC,EAAE,IAAI,CAAe,EAAE,SAAS,CAAC;CAC/D,mBAAmB,EAChB,MAAM,CAAC,GAAsB,EAAE,OAAO,CAAC,CAAC,EACxC,WAAU,MAAM,OAAO,KAAM,WAAW,OAAO,CAAC,IAAI,CAAE,EACtD,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,IAAI,CAAC,EAAE,SAAS,CAAC;CAC1C,YAAY,EACT,MACC,EACG,MAAM,CACL,EAAE,OAAO,GAET,EAAE,OAAO,EAAE,IAAI,CACjB,CAAC,EACA,KAAK,EAAE,OAAO,OAAO,CAAC,CAC3B,EACC,IAAA,KAAqB,EACpB,SAAS,mDACX,CAAC,EACA,SAAS;CACZ,gBAAgB,EAAE,MAAM,CAA2B,EAAE,SAAS;CAC9D,WAAW,EAAgB,SAAS;CACpC,iBAAiB,EAA4B,SAAS;AACxD,CAAC;AAMD,SAAS,EACP,GACA,GACA,GACA,GACe;CACf,IAAM,IAAS,EAAO,UAAU,CAAK;CACrC,IAAI,EAAO,SACT,OAAO,EAAO;CAEhB,EAAO,MAAM,OAAO,SAAQ,MAAS;EACnC,EAAI,SAAS;GAAE,GAAG;GAAO,MAAM,CAAC,CAAI;EAAE,CAAC;CACzC,CAAC;AAEH;AAQA,IAAa,IAAuB,EACjC,QAAO,MAAQ,EAAK,eAAe,QAAQ,EAAY,EAAK,UAAU,GAAG;CACxE,SAAS;CACT,MAAM,CAAC,aAAa;AACtB,CAAC,EACA,QACC,MACE,EAAK,qBAAqB,QAAQ,EAAqB,EAAK,UAAU,GACxE;CACE,SAAS;CACT,MAAM,CAAC,mBAAmB;AAC5B,CACF,EACC,aAAa,GAAM,MAAQ;CAC1B,IACE,EAAK,qBAAqB,QAC1B,CAAC,EAAqB,EAAK,UAAU,GAGrC;CAEF,IAAM,IAAgB,EACpB,EAAK,YACL,EAAK,WACP;CACA,AAAI,EAAK,oBAAoB,KAC3B,EAAI,SAAS;EACX,MAAM;EACN,SAAS,uCAAuC,EAAc;EAC9D,MAAM,CAAC,mBAAmB;CAC5B,CAAC;AAEL,CAAC,EACA,QACC,MACM,EAAK,kBAAkB,OAGpB,KAFE,EAAK,eAAe,EAAe,MAI9C;CACE,SAAS;CACT,MAAM,CAAC,YAAY;AACrB,CACF,EACC,QACC,MAOI,EAJA,EAAK,gBAAgB,QACrB,EAAK,iBAAiB,MACtB,EAAE,MAAM,QAAQ,EAAK,YAAY,KAAK,EAAK,aAAa,WAAW,OAGnE,CAAC,EAAsC,SAAS,EAAK,UAAU,GAGnE;CACE,SAAS;CACT,MAAM,CAAC,cAAc;AACvB,CACF,EACC,WAAW,GAAM,MAEZ,EAAK,gBAAgB,OAChB,EAAK,GAAM,cAAc,IAE3B;CACL,GAAG;CACH,cAAc,EACZ,EAAK,cACL,EAAyB,EAAK,UAAU,GACxC,gBACA,CACF;AACF,CACD,EACA,WAAW,GAAM,MAEZ,EAAK,cAAc,OACd,EAAK,GAAM,YAAY,IAEzB;CACL,GAAG;CACH,YAAY,EACV,EAAK,YACL,EAAuB,EAAK,UAAU,GACtC,cACA,CACF;AACF,CACD,GAEU,IAA+B,EAAE,MAAM,CAAoB,GAElE,IAAmC,EAA4B,OAAO,EAC1E,YAAY,EAAE,QAAQ,EACxB,CAAC;AAOkC,EAA2B,OAAO;CACnE,YAAY,EAAE,QAAQ;CACtB,2BAA2B,EAAE,QAAQ;CACrC,gBAAgB,EAAE,MAAM,CAAgC,EAAE,SAAS;AACrE,CAAC;AAQD,SAAgB,EACd,GAIwD;CACxD,OAAO,EAA6B,UAAU,CAAQ;AACxD"}

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/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,OAAO,EAAE,WAAW,GAAM,MAAQ;CAEvD,IAAI;EAAC;EAAO;EAAY;CAAW,EAAE,SAAS,CAAI,GAChD,OAAO;CAET,IAAM,IAAS,OAAO,CAAI;CAW1B,OATI,MAAM,CAAM,KACd,EAAI,SAAS;EACX,MAAM,EAAE,aAAa;EACrB,UAAU;EACV,UAAU;EACV,MAAM,CAAC;EACP,SAAS;CACX,CAAC,GAEI;AACT,CAAC,GAKY,IAAe,EACzB,MAAM;CAAC,EAAE,OAAO;CAAG,EAAE,IAAI;CAAG;AAAY,CAAC,EACzC,WAAW,MACN,OAAO,KAAQ,WAEb,MAAM,CAAG,IACJ,QACE,MAAQ,WACV,aACE,MAAQ,YACV,cAEF,IAEF,CACR"}
+{"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/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,OAAO,EAEP,WAAU,MAAS,MAAS,KAAK,OAAO,CAAK;CAChD,EAAE,KAAK;CACP,EAAE,OAAO,EAAE,IAAI;AACjB,CAAC,EACA,KAAK,EAAE,MAAM,CAAC,EAAE,KAAK,GAAG,EAAE,OAAO,OAAO,EAAE,IAAI,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/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,OAAO,EAAE,WAAW,GAAM,MAAQ;CACxE,IAAI;EACF,IAAM,IAAS,KAAK,MAAM,CAAI;EAO9B,OANK,MAAM,QAAQ,CAAM,KACvB,EAAI,SAAS;GACX,MAAM,EAAE,aAAa;GACrB,SAAS;EACX,CAAC,GAEI;CACT,QAAY;EACV,EAAI,SAAS;GACX,MAAM,EAAE,aAAa;GACrB,SAAS;EACX,CAAC;CACH;CACA,OAAO;AACT,CAAC;AAED,SAAwB,EACtB,GACY;CACZ,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,QAClB,OAAO,EAAE,OAAO,OAAO;EACzB,KAAK,EAAe,SAClB,OAAO;EACT,KAAK,EAAe,SAClB,OAAO;EACT,KAAK,EAAe,QAClB,OAAO;EACT,KAAK,EAAe,MAClB,OAAO;EACT,KAAK,EAAe,cAClB,OAAO;EACT,KAAK,EAAe,UAClB,OAAO;EACT,KAAK,EAAe,MAClB,OAAO,EAAE,OAAO,OAAO;EACzB,KAAK,EAAe,YAClB,OAAO,EAAE,OAAO,OAAO;EACzB,KAAK,EAAe,WAClB,OAAO,EAAE,OAAO,OAAO;EACzB,KAAK,EAAe,QAClB,OAAO;EACT,KAAK,EAAe,cAClB,OAAO;EACT,KAAK,EAAe,cAClB,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"}
+{"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/UserCardList/UserCardList.d.ts

@@ -1,28 +1,10 @@
 import { UserCardSize } from '@/utils/SynapseConstants';
-import { RowSet, UserProfile } from '@sage-bionetworks/synapse-types';
-import { Component } from 'react';
+import { RowSet } from '@sage-bionetworks/synapse-types';
 export type UserCardListProps = {
     list: (string | null)[];
     size?: UserCardSize;
     rowSet?: RowSet;
 };
-export type UserCardListState = {
-    userProfileMap: Record<string, UserProfile>;
-};
-export declare class UserCardList extends Component<UserCardListProps, UserCardListState> {
-    constructor(props: UserCardListProps);
-    componentDidMount(): void;
-    componentDidUpdate(prevProps: UserCardListProps): void;
-    update(list: (string | null)[]): void;
-    /**
-     * Given data this will find rows where there is no userId columnType and create faux user profiles
-     * using firstName, lastName, and institution (company in UserProfile object).
-     * @param {RowSet} rowSet
-     * @returns list of UserProfiles with firstName, lastName, company, userName (first letter of firstName) filled out.
-     * @memberof UserCardList
-     */
-    manuallyExtractData(rowSet: RowSet): Omit<UserProfile, "ownerId">[];
-    render(): import("react/jsx-runtime").JSX.Element;
-}
+export declare function UserCardList(props: UserCardListProps): import("react/jsx-runtime").JSX.Element;
 export default UserCardList;
 //# sourceMappingURL=UserCardList.d.ts.map

package/dist/components/UserCardList/UserCardList.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"UserCardList.d.ts","sourceRoot":"","sources":["../../../src/components/UserCardList/UserCardList.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAoB,YAAY,EAAE,MAAM,0BAA0B,CAAA;AACzE,OAAO,EAEL,MAAM,EACN,WAAW,EACZ,MAAM,iCAAiC,CAAA;AAExC,OAAO,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA;AAGjC,MAAM,MAAM,iBAAiB,GAAG;IAE9B,IAAI,EAAE,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,CAAA;IACvB,IAAI,CAAC,EAAE,YAAY,CAAA;IAGnB,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB,CAAA;AAED,MAAM,MAAM,iBAAiB,GAAG;IAC9B,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAA;CAC5C,CAAA;AACD,qBAAa,YAAa,SAAQ,SAAS,CACzC,iBAAiB,EACjB,iBAAiB,CAClB;gBACa,KAAK,EAAE,iBAAiB;IAQpC,iBAAiB;IAKjB,kBAAkB,CAAC,SAAS,EAAE,iBAAiB;IAY/C,MAAM,CAAC,IAAI,EAAE,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE;IAmB9B;;;;;;OAMG;IACH,mBAAmB,CAAC,MAAM,EAAE,MAAM;IA0BlC,MAAM;CAqDP;AACD,eAAe,YAAY,CAAA"}
+{"version":3,"file":"UserCardList.d.ts","sourceRoot":"","sources":["../../../src/components/UserCardList/UserCardList.tsx"],"names":[],"mappings":"AACA,OAAO,EAAoB,YAAY,EAAE,MAAM,0BAA0B,CAAA;AACzE,OAAO,EAEL,MAAM,EAEP,MAAM,iCAAiC,CAAA;AAIxC,MAAM,MAAM,iBAAiB,GAAG;IAE9B,IAAI,EAAE,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,CAAA;IACvB,IAAI,CAAC,EAAE,YAAY,CAAA;IAGnB,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB,CAAA;AA8BD,wBAAgB,YAAY,CAAC,KAAK,EAAE,iBAAiB,2CAkEpD;AAED,eAAe,YAAY,CAAA"}

package/dist/components/UserCardList/UserCardList.js

@@ -1,78 +1,55 @@
 import { MEDIUM_USER_CARD as e } from "../../utils/SynapseConstants.js";
-import { getUserProfileWithProfilePicAttached as t } from "../../utils/functions/getUserData.js";
+import { useGetUserProfilesWithProfilePicAttached as t } from "../../synapse-queries/user/useUserBundle.js";
 import { UserCard as n } from "../UserCard/UserCard.js";
-import { Component as r } from "react";
-import { without as i } from "lodash-es";
-import { jsx as a } from "react/jsx-runtime";
-import { ColumnTypeEnum as o } from "@sage-bionetworks/synapse-types";
+import { useMemo as r } from "react";
+import { jsx as i } from "react/jsx-runtime";
+import { ColumnTypeEnum as a } from "@sage-bionetworks/synapse-types";
 //#region src/components/UserCardList/UserCardList.tsx
-var s = class extends r {
-	constructor(e) {
-		super(e), this.state = { userProfileMap: {} }, this.update = this.update.bind(this);
-	}
-	componentDidMount() {
-		let { list: e } = this.props;
-		this.update(e);
-	}
-	componentDidUpdate(e) {
-		let t = e.list, n = i(this.props.list.filter((e) => e), ...t);
-		n.length > 0 && this.update(n);
-	}
-	update(e) {
-		t(e.filter((e) => !!e)).then((e) => {
-			let t = {};
-			e.list.forEach((e) => {
-				let { ownerId: n } = e;
-				t[n] = e;
-			}), this.setState({ userProfileMap: {
-				...this.state.userProfileMap,
-				...t
-			} });
-		}).catch((e) => {
-			console.error("Error on batch call =", e);
-		});
-	}
-	manuallyExtractData(e) {
-		let t = e.headers.findIndex((e) => e.name === "firstName"), n = e.headers.findIndex((e) => e.name === "lastName"), r = e.headers.findIndex((e) => e.name === "institution"), i = e.headers.findIndex((e) => e.columnType === o.USERID);
-		return e.rows.filter((e) => !e.values[i]).map((e) => {
-			let i = e.values;
-			return {
-				firstName: i[t] ?? "",
-				lastName: i[n] ?? "",
-				company: i[r] ?? void 0,
-				ownerId: null,
-				userName: i[t] ? i[t][0] ?? "" : ""
-			};
-		});
-	}
-	render() {
-		let { size: t = e, rowSet: r, list: i } = this.props, { userProfileMap: o = {} } = this.state, s = r && this.manuallyExtractData(r), c = 0;
-		return /* @__PURE__ */ a("div", {
-			className: "SRC-card-grid-row",
-			children: i.map((e) => {
-				let r = e == null ? null : o[e];
-				if (r) return /* @__PURE__ */ a("div", {
-					className: "SRC-grid-item SRC-narrow-grid-item",
-					children: /* @__PURE__ */ a(n, {
-						size: t,
-						preSignedURL: r.clientPreSignedURL,
-						userProfile: r
-					})
-				}, JSON.stringify(r));
-				let i = s && s[c];
-				return i ? (c += 1, /* @__PURE__ */ a("div", {
-					className: "SRC-grid-item SRC-narrow-grid-item",
-					children: /* @__PURE__ */ a(n, {
-						disableLink: !0,
-						hideEmail: !0,
-						size: t,
-						userProfile: i
-					})
-				}, JSON.stringify(i))) : !1;
-			})
-		});
-	}
-};
+function o(e) {
+	let t = e.headers.findIndex((e) => e.name === "firstName"), n = e.headers.findIndex((e) => e.name === "lastName"), r = e.headers.findIndex((e) => e.name === "institution"), i = e.headers.findIndex((e) => e.columnType === a.USERID);
+	return e.rows.filter((e) => !e.values[i]).map((e) => {
+		let i = e.values;
+		return {
+			firstName: i[t] ?? "",
+			lastName: i[n] ?? "",
+			company: i[r] ?? void 0,
+			ownerId: null,
+			userName: i[t] ? i[t][0] ?? "" : ""
+		};
+	});
+}
+function s(a) {
+	let { list: s, size: c = e, rowSet: l } = a, { data: u } = t(r(() => s.filter((e) => !!e), [s])), d = r(() => {
+		let e = {};
+		return u?.list.forEach((t) => {
+			t.ownerId && (e[t.ownerId] = t);
+		}), e;
+	}, [u]), f = l ? o(l) : void 0, p = 0;
+	return /* @__PURE__ */ i("div", {
+		className: "SRC-card-grid-row",
+		children: s.map((e) => {
+			let t = e == null ? null : d[e];
+			if (t) return /* @__PURE__ */ i("div", {
+				className: "SRC-grid-item SRC-narrow-grid-item",
+				children: /* @__PURE__ */ i(n, {
+					size: c,
+					preSignedURL: t.clientPreSignedURL,
+					userProfile: t
+				})
+			}, JSON.stringify(t));
+			let r = f && f[p];
+			return r ? (p += 1, /* @__PURE__ */ i("div", {
+				className: "SRC-grid-item SRC-narrow-grid-item",
+				children: /* @__PURE__ */ i(n, {
+					disableLink: !0,
+					hideEmail: !0,
+					size: c,
+					userProfile: r
+				})
+			}, JSON.stringify(r))) : !1;
+		})
+	});
+}
 //#endregion
 export { s as UserCardList, s as default };