@resistdesign/voltra 3.0.0-alpha.33 → 3.0.0-alpha.35

package/app/index.js

@@ -1,8 +1,8 @@
-export { createEasyLayout, getEasyLayoutTemplateDetails, getPascalCaseAreaName } from '../chunk-FQMZMCXU.js';
-export { Route, RouteContext, RouteContextConsumer, RouteContextProvider, RouteProvider, buildHistoryPath, buildQueryString, buildRoutePath, canUseBrowserHistory, computeTrackPixels, createBrowserRouteAdapter, createHistoryBackHandler, createManualRouteAdapter, createMemoryHistory, createNativeRouteAdapter, createRouteAdapterFromHistory, createUniversalAdapter, parseHistoryPath, useRouteContext } from '../chunk-G5CLUK4Y.js';
-export { AutoForm, AutoFormView, computeAreaBounds, createAutoField, createFormRenderer, getFieldKind, parseTemplate, resolveSuite, useFormEngine, validateAreas } from '../chunk-WELZGQDJ.js';
+export { createEasyLayout, getEasyLayoutTemplateDetails, getPascalCaseAreaName } from '../chunk-BKRJZXWX.js';
+export { computeTrackPixels } from '../chunk-TJFTWPXQ.js';
+export { AutoForm, AutoFormView, Route, RouteContext, RouteContextConsumer, RouteContextProvider, RouteProvider, buildHistoryPath, buildQueryString, buildRoutePath, canUseBrowserHistory, computeAreaBounds, createAutoField, createBrowserRouteAdapter, createFormRenderer, createHistoryBackHandler, createManualRouteAdapter, createMemoryHistory, createNativeRouteAdapter, createRouteAdapterFromHistory, createUniversalAdapter, defaultTranslateValidationErrorCode, getFieldKind, parseHistoryPath, parseTemplate, resolveSuite, useFormEngine, useRouteContext, validateAreas } from '../chunk-X3NHBZUT.js';
 import '../chunk-7AMEFPPP.js';
-import '../chunk-IWRHGGGH.js';
+import '../chunk-WTD5BBJP.js';
 import { mergeStringPaths, PATH_DELIMITER } from '../chunk-GYWRAW3Y.js';
 import '../chunk-I2KLQ2HA.js';
 import { createContext, useContext, useRef, useMemo, useCallback, useState, useEffect } from 'react';
@@ -38,6 +38,8 @@ var useApplicationStateValue = (identifier) => {
   } = useContext(ApplicationStateContext);
   const appStateRef = useRef(applicationState);
   appStateRef.current = applicationState;
+  const modificationStateRef = useRef(modificationState);
+  modificationStateRef.current = modificationState;
   const modified = useMemo(
     () => getApplicationStateModified(identifier, modificationState),
     [identifier, modificationState]
@@ -49,7 +51,11 @@ var useApplicationStateValue = (identifier) => {
   const setModified = useCallback(
     (isModified) => {
       setModificationState(
-        setApplicationStateModified(identifier, isModified, modificationState)
+        setApplicationStateModified(
+          identifier,
+          isModified,
+          modificationStateRef.current
+        )
       );
     },
     [identifier, setModificationState]
@@ -130,6 +136,8 @@ var ApplicationStateProvider = ({
 
 // src/app/utils/Service.ts
 var getFullUrl = (protocol, domain, basePath = "", path = "", port) => {
+  const normalizedProtocol = protocol.endsWith(":") ? protocol.slice(0, -1) : protocol;
+  const normalizedDomain = domain.replace(/\/+$/, "");
   const portString = !!port ? `:${port}` : "";
   const fullPath = mergeStringPaths(
     basePath,
@@ -139,7 +147,8 @@ var getFullUrl = (protocol, domain, basePath = "", path = "", port) => {
     false,
     false
   );
-  return `${protocol}://${domain}${portString}${fullPath}`;
+  const normalizedPath = fullPath ? fullPath.startsWith(PATH_DELIMITER) ? fullPath : `${PATH_DELIMITER}${fullPath}` : "";
+  return `${normalizedProtocol}://${normalizedDomain}${portString}${normalizedPath}`;
 };
 var sendServiceRequest = async (config, path = "", args = []) => {
   const { protocol, domain, port, basePath = "", authorization = "" } = config;
@@ -229,7 +238,7 @@ var useApplicationStateLoader = (config) => {
 var getKeyValueWithoutError = (obj, key) => {
   try {
     return obj[key];
-  } catch (e) {
+  } catch (_error) {
     return void 0;
   }
 };
@@ -240,7 +249,8 @@ var useController = (parentValue, key, onParentValueChange, isArrayIndex = false
       try {
         setValue(value2);
         if (isArrayIndex) {
-          const newArray = [...parentValue];
+          const baseArray = Array.isArray(parentValue) ? parentValue : [];
+          const newArray = [...baseArray];
           newArray[key] = value2;
           onParentValueChange(newArray);
         } else {
@@ -249,7 +259,7 @@ var useController = (parentValue, key, onParentValueChange, isArrayIndex = false
             [key]: value2
           });
         }
-      } catch (e) {
+      } catch (_error) {
       }
     },
     [parentValue, key, onParentValueChange, isArrayIndex]
@@ -257,7 +267,7 @@ var useController = (parentValue, key, onParentValueChange, isArrayIndex = false
   useEffect(() => {
     try {
       setValue(getKeyValueWithoutError(parentValue, key));
-    } catch (e) {
+    } catch (_error) {
       setValue(void 0);
     }
   }, [parentValue, key]);
@@ -378,8 +388,7 @@ var useTypeInfoORMAPI = (typeInfoORMAPI) => {
   );
   const api = useMemo(() => {
     const apiBase = {};
-    for (const aM in typeInfoORMAPI) {
-      const methodName = aM;
+    for (const methodName of Object.keys(typeInfoORMAPI)) {
       apiBase[methodName] = requestHandlerFactory(
         typeInfoORMAPI,
         methodName,

package/app/utils/ApplicationState.d.ts

@@ -60,7 +60,7 @@ export declare const getApplicationStateValue: (identifier: ApplicationStateIden
  * @param modificationState - The current modification map.
  * @returns A new modification map with the updated flag.
  * */
-export declare const setApplicationStateModified: (identifier: ApplicationStateIdentifier, value: boolean, modificationState: ApplicationState) => ApplicationStateModificationState;
+export declare const setApplicationStateModified: (identifier: ApplicationStateIdentifier, value: boolean, modificationState: ApplicationStateModificationState) => ApplicationStateModificationState;
 /**
  * Set the stored value for an identifier.
  *

package/build/index.js

@@ -394,7 +394,7 @@ var getTypeInfoFromPickOmitFieldFilters = (typeNameStr, typeRef, typeMap) => {
         (fieldSet) => fieldSet.filter(
           (field) => picking ? omitFieldNames.includes(field) : !omitFieldNames.includes(field)
         )
-      ) : void 0;
+      ).filter((fieldSet) => fieldSet.length > 0) : void 0;
       typeInfo = {
         ...typeInfoOther,
         fields: cleanTypeInfoFields,
@@ -438,7 +438,7 @@ var getTypeInfoFromExcludeFieldFilter = (_typeNameStr, typeRef, typeMap) => {
         );
         const cleanUnionFieldSets = existingUnionFieldSets ? existingUnionFieldSets.map(
           (fieldSet) => fieldSet.filter((field) => !excludeFieldNames.includes(field))
-        ) : void 0;
+        ).filter((fieldSet) => fieldSet.length > 0) : void 0;
         typeInfo = {
           ...baseTypeInfo,
           fields: cleanTypeInfoFields,

package/{chunk-FQMZMCXU.js → chunk-BKRJZXWX.js}

@@ -1,4 +1,4 @@
-import { parseTemplate, validateAreas } from './chunk-WELZGQDJ.js';
+import { parseTemplate, validateAreas } from './chunk-X3NHBZUT.js';
 
 // src/app/utils/EasyLayout.tsx
 var getPascalCaseAreaName = (area) => {

package/chunk-TJFTWPXQ.js

@@ -0,0 +1,39 @@
+// src/app/utils/easy-layout/computeTracks.ts
+var computeTrackPixels = ({
+  tracks,
+  totalPx,
+  gapPx = 0,
+  paddingPx = 0
+}) => {
+  if (!tracks.length) {
+    return [];
+  }
+  const gapsPx = Math.max(0, tracks.length - 1) * Math.max(0, gapPx);
+  const usablePx = Math.max(0, totalPx - Math.max(0, paddingPx) * 2 - gapsPx);
+  let fixedPx = 0;
+  let frTotal = 0;
+  for (const track of tracks) {
+    if (track.kind === "px") {
+      fixedPx += track.value;
+    } else if (track.kind === "pct") {
+      fixedPx += usablePx * track.value / 100;
+    } else {
+      frTotal += track.value;
+    }
+  }
+  const remainderPx = Math.max(0, usablePx - fixedPx);
+  return tracks.map((track) => {
+    if (track.kind === "px") {
+      return track.value;
+    }
+    if (track.kind === "pct") {
+      return usablePx * track.value / 100;
+    }
+    if (frTotal <= 0) {
+      return 0;
+    }
+    return remainderPx * track.value / frTotal;
+  });
+};
+
+export { computeTrackPixels };

package/{chunk-LGM75I6P.js → chunk-WTD5BBJP.js}

@@ -1,5 +1,14 @@
 import { getPathString } from './chunk-GYWRAW3Y.js';
 
+// src/common/TypeParsing/TypeInfo.ts
+var TypeOperation = /* @__PURE__ */ ((TypeOperation2) => {
+  TypeOperation2["CREATE"] = "CREATE";
+  TypeOperation2["READ"] = "READ";
+  TypeOperation2["UPDATE"] = "UPDATE";
+  TypeOperation2["DELETE"] = "DELETE";
+  return TypeOperation2;
+})(TypeOperation || {});
+
 // src/common/TypeParsing/Validation.ts
 var RelationshipValidationType = /* @__PURE__ */ ((RelationshipValidationType2) => {
   RelationshipValidationType2["INCLUDE"] = "INCLUDE";
@@ -13,8 +22,23 @@ var PRIMITIVE_ERROR_MESSAGE_CONSTANTS = {
   number: "NOT_A_NUMBER",
   boolean: "NOT_A_BOOLEAN"
 };
+var DENIED_TYPE_OPERATIONS = {
+  CREATE: "DENIED_TYPE_OPERATION_CREATE",
+  READ: "DENIED_TYPE_OPERATION_READ",
+  UPDATE: "DENIED_TYPE_OPERATION_UPDATE",
+  DELETE: "DENIED_TYPE_OPERATION_DELETE"
+};
 var ERROR_MESSAGE_CONSTANTS = {
-  MISSING: "MISSING",
+  NONE: "NONE",
+  INVALID_CUSTOM_TYPE,
+  [PRIMITIVE_ERROR_MESSAGE_CONSTANTS.string]: PRIMITIVE_ERROR_MESSAGE_CONSTANTS.string,
+  [PRIMITIVE_ERROR_MESSAGE_CONSTANTS.number]: PRIMITIVE_ERROR_MESSAGE_CONSTANTS.number,
+  [PRIMITIVE_ERROR_MESSAGE_CONSTANTS.boolean]: PRIMITIVE_ERROR_MESSAGE_CONSTANTS.boolean,
+  [DENIED_TYPE_OPERATIONS.CREATE]: DENIED_TYPE_OPERATIONS.CREATE,
+  [DENIED_TYPE_OPERATIONS.READ]: DENIED_TYPE_OPERATIONS.READ,
+  [DENIED_TYPE_OPERATIONS.UPDATE]: DENIED_TYPE_OPERATIONS.UPDATE,
+  [DENIED_TYPE_OPERATIONS.DELETE]: DENIED_TYPE_OPERATIONS.DELETE,
+  MISSING_FIELD_VALUE: "MISSING_FIELD_VALUE",
   INVALID_OPTION: "INVALID_OPTION",
   INVALID_FIELD: "INVALID_FIELD",
   RELATIONSHIP_VALUES_ARE_STRICTLY_EXCLUDED: "RELATIONSHIP_VALUES_ARE_STRICTLY_EXCLUDED",
@@ -22,34 +46,61 @@ var ERROR_MESSAGE_CONSTANTS = {
   NO_UNION_TYPE_MATCHED: "NO_UNION_TYPE_MATCHED",
   TYPE_DOES_NOT_EXIST: "TYPE_DOES_NOT_EXIST",
   INVALID_PATTERN: "INVALID_PATTERN",
-  VALUE_DOES_NOT_MATCH_PATTERN: "VALUE_DOES_NOT_MATCH_PATTERN"
+  VALUE_DOES_NOT_MATCH_PATTERN: "VALUE_DOES_NOT_MATCH_PATTERN",
+  VALUE_BELOW_MINIMUM: "VALUE_BELOW_MINIMUM",
+  VALUE_ABOVE_MAXIMUM: "VALUE_ABOVE_MAXIMUM"
 };
-var DENIED_TYPE_OPERATIONS = {
-  CREATE: "DENIED_TYPE_OPERATION_CREATE",
-  READ: "DENIED_TYPE_OPERATION_READ",
-  UPDATE: "DENIED_TYPE_OPERATION_UPDATE",
-  DELETE: "DENIED_TYPE_OPERATION_DELETE"
+var TYPE_KEYWORD_ERROR_MESSAGE_CONSTANTS = {
+  string: PRIMITIVE_ERROR_MESSAGE_CONSTANTS.string,
+  number: PRIMITIVE_ERROR_MESSAGE_CONSTANTS.number,
+  boolean: PRIMITIVE_ERROR_MESSAGE_CONSTANTS.boolean
 };
+var ARRAY_ITEM_ERROR_MAP_KEY = "__arrayItemErrors__";
+var getErrorDescriptor = (code = ERROR_MESSAGE_CONSTANTS.NONE, values) => ({
+  code,
+  values
+});
+var getNoErrorDescriptor = () => getErrorDescriptor(ERROR_MESSAGE_CONSTANTS.NONE);
+var isArrayErrorDescriptorCollection = (value) => typeof value === "object" && value !== null && "itemErrorMap" in value;
+var getErrorDescriptors = (values = []) => values.filter(
+  (value) => !isArrayErrorDescriptorCollection(value)
+);
+var getArrayItemErrorMap = (values = []) => values.reduce((acc, value) => {
+  if (isArrayErrorDescriptorCollection(value)) {
+    for (const [indexKey, descriptors] of Object.entries(value.itemErrorMap)) {
+      const index = Number(indexKey);
+      if (!Number.isFinite(index)) {
+        continue;
+      }
+      acc[index] = [...acc[index] ?? [], ...descriptors];
+    }
+  }
+  return acc;
+}, {});
 var validateValueMatchesPattern = (typeName, value, pattern) => {
   const results = {
     typeName,
     valid: true,
-    error: "",
+    error: getNoErrorDescriptor(),
     errorMap: {}
   };
   const valueSupplied = typeof value !== "undefined";
   const patternSupplied = typeof pattern === "string" && pattern.trim() !== "";
-  if (!valueSupplied || !patternSupplied) {
+  if (valueSupplied && patternSupplied) {
     try {
       const regex = new RegExp(pattern);
       const testResult = typeof value === "string" && regex.test(value);
       if (!testResult) {
         results.valid = false;
-        results.error = ERROR_MESSAGE_CONSTANTS.VALUE_DOES_NOT_MATCH_PATTERN;
+        results.error = getErrorDescriptor(
+          ERROR_MESSAGE_CONSTANTS.VALUE_DOES_NOT_MATCH_PATTERN
+        );
       }
     } catch (e) {
       results.valid = false;
-      results.error = ERROR_MESSAGE_CONSTANTS.INVALID_PATTERN;
+      results.error = getErrorDescriptor(
+        ERROR_MESSAGE_CONSTANTS.INVALID_PATTERN
+      );
     }
   }
   return results;
@@ -90,23 +141,40 @@ var validateTypeInfoFieldValue = (value, typeInfoField, typeInfoMap, ignoreArray
     array,
     optional,
     possibleValues,
-    tags: { customType, constraints: { pattern = void 0 } = {} } = {}
+    tags: {
+      customType,
+      validation: {
+        emptyArrayIsValid: emptyArrayIsValidOverride = void 0
+      } = {},
+      constraints: {
+        pattern = void 0,
+        min = void 0,
+        max = void 0
+      } = {}
+    } = {}
   } = typeInfoField;
   const results = {
     typeName: typeReference ?? type,
     valid: true,
-    error: "",
+    error: getNoErrorDescriptor(),
     errorMap: {}
   };
   const requiredValueAllowed = !typeReference || relationshipValidationType === "INCLUDE" /* INCLUDE */;
   const valueIsUndefined = typeof value === "undefined";
   const valueIsNull = value === null;
   const canSkipValidation = itemIsPartial && (valueIsUndefined || valueIsNull) || optional && valueIsUndefined;
+  const emptyArrayIsValid = emptyArrayIsValidOverride ?? false;
   if (canSkipValidation) {
     results.valid = true;
   } else if (requiredValueAllowed && !itemIsPartial && !optional && !hasValue(value)) {
     results.valid = false;
-    results.error = ERROR_MESSAGE_CONSTANTS.MISSING;
+    results.error = getErrorDescriptor(ERROR_MESSAGE_CONSTANTS.MISSING_FIELD_VALUE);
+  } else if (array && !ignoreArray && !Array.isArray(value)) {
+    results.valid = false;
+    results.error = getErrorDescriptor(ERROR_MESSAGE_CONSTANTS.INVALID_TYPE);
+  } else if (array && !ignoreArray && !optional && Array.isArray(value) && value.length === 0 && !emptyArrayIsValid) {
+    results.valid = false;
+    results.error = getErrorDescriptor(ERROR_MESSAGE_CONSTANTS.MISSING_FIELD_VALUE);
   } else if (array && !ignoreArray) {
     const {
       valid: validArray,
@@ -149,14 +217,18 @@ var validateTypeInfoFieldValue = (value, typeInfoField, typeInfoMap, ignoreArray
         const valueSupplied = typeof value !== "undefined";
         if (valueSupplied) {
           results.valid = false;
-          results.error = ERROR_MESSAGE_CONSTANTS.RELATIONSHIP_VALUES_ARE_STRICTLY_EXCLUDED;
+          results.error = getErrorDescriptor(
+            ERROR_MESSAGE_CONSTANTS.RELATIONSHIP_VALUES_ARE_STRICTLY_EXCLUDED
+          );
         }
       } else if (relationshipValidationType === "EXCLUDE" /* EXCLUDE */) {
         results.valid = getValidityValue(results.valid, true);
       }
     } else if (possibleValues && !possibleValues.includes(value)) {
       results.valid = false;
-      results.error = ERROR_MESSAGE_CONSTANTS.INVALID_OPTION;
+      results.error = getErrorDescriptor(
+        ERROR_MESSAGE_CONSTANTS.INVALID_OPTION
+      );
     } else {
       const pendingValid = validateKeywordType(value, type);
       const customValid = validateCustomType(
@@ -167,14 +239,33 @@ var validateTypeInfoFieldValue = (value, typeInfoField, typeInfoMap, ignoreArray
       results.valid = getValidityValue(results.valid, pendingValid);
       results.valid = getValidityValue(results.valid, customValid);
       if (type === "string" && typeof pattern === "string") {
-        const { valid: patternValid, error: patternError } = validateValueMatchesPattern(value, pattern);
+        const { valid: patternValid, error: patternError } = validateValueMatchesPattern(typeReference ?? type, value, pattern);
         results.valid = getValidityValue(results.valid, patternValid);
         results.error = patternError;
       }
+      if (type === "number" && typeof value === "number") {
+        if (typeof min === "number" && value < min) {
+          results.valid = false;
+          results.error = getErrorDescriptor(
+            ERROR_MESSAGE_CONSTANTS.VALUE_BELOW_MINIMUM,
+            [`${min}`]
+          );
+        } else if (typeof max === "number" && value > max) {
+          results.valid = false;
+          results.error = getErrorDescriptor(
+            ERROR_MESSAGE_CONSTANTS.VALUE_ABOVE_MAXIMUM,
+            [`${max}`]
+          );
+        }
+      }
       if (!customValid) {
-        results.error = INVALID_CUSTOM_TYPE;
+        results.error = getErrorDescriptor(
+          ERROR_MESSAGE_CONSTANTS.INVALID_CUSTOM_TYPE
+        );
       } else if (!results.valid) {
-        results.error = results.error ? results.error : PRIMITIVE_ERROR_MESSAGE_CONSTANTS[type];
+        results.error = results.error.code !== ERROR_MESSAGE_CONSTANTS.NONE ? results.error : getErrorDescriptor(
+          TYPE_KEYWORD_ERROR_MESSAGE_CONSTANTS[type]
+        );
       }
     }
   }
@@ -185,14 +276,15 @@ var validateArrayOfTypeInfoFieldValues = (values = [], typeInfoField, typeInfoMa
   const results = {
     typeName: typeReference ?? type,
     valid: true,
-    error: "",
+    error: getNoErrorDescriptor(),
     errorMap: {}
   };
+  const itemErrorMap = {};
   for (let i = 0; i < values.length; i++) {
     const v = values[i];
     const {
       valid: indexValid,
-      error: indexError = "",
+      error: indexError = getNoErrorDescriptor(),
       errorMap: indexErrorMap
     } = validateTypeInfoFieldValue(
       v,
@@ -206,18 +298,32 @@ var validateArrayOfTypeInfoFieldValues = (values = [], typeInfoField, typeInfoMa
       itemIsPartial
     );
     results.valid = getValidityValue(results.valid, indexValid);
-    results.errorMap[getPathString([i])] = [indexError];
-    for (const er in indexErrorMap) {
-      results.errorMap[getPathString([i, er])] = indexErrorMap[er];
+    const indexErrors = [
+      ...indexError.code !== ERROR_MESSAGE_CONSTANTS.NONE ? [indexError] : [],
+      ...getErrorDescriptors(indexErrorMap[ARRAY_ITEM_ERROR_MAP_KEY] ?? []),
+      ...Object.entries(indexErrorMap).filter(([key]) => key !== ARRAY_ITEM_ERROR_MAP_KEY).flatMap(([, entries]) => getErrorDescriptors(entries)).filter((descriptor) => descriptor.code !== ERROR_MESSAGE_CONSTANTS.NONE)
+    ];
+    if (indexErrors.length) {
+      itemErrorMap[i] = indexErrors;
+      if (results.error.code === ERROR_MESSAGE_CONSTANTS.NONE) {
+        results.error = indexErrors[0];
+      }
+    }
+    for (const [er, entries] of Object.entries(indexErrorMap)) {
+      if (er === ARRAY_ITEM_ERROR_MAP_KEY) {
+        continue;
+      }
+      results.errorMap[getPathString([i, er])] = entries;
     }
   }
+  results.errorMap[ARRAY_ITEM_ERROR_MAP_KEY] = [{ itemErrorMap }];
   return results;
 };
 var validateTypeInfoFieldOperationAllowed = (fieldName, fieldOperation, typeInfoField) => {
   const results = {
     typeName: null,
     valid: true,
-    error: "",
+    error: getNoErrorDescriptor(),
     errorMap: {}
   };
   if (fieldOperation && typeInfoField) {
@@ -230,7 +336,9 @@ var validateTypeInfoFieldOperationAllowed = (fieldName, fieldOperation, typeInfo
     results.typeName = typeReference ?? type;
     results.valid = !denied;
     if (!results.valid) {
-      results.error = DENIED_TYPE_OPERATIONS[fieldOperation];
+      results.error = getErrorDescriptor(
+        DENIED_TYPE_OPERATIONS[fieldOperation]
+      );
       results.errorMap[fieldName] = [results.error];
     }
   }
@@ -240,14 +348,14 @@ var validateTypeOperationAllowed = (typeName, valueFields, typeOperation, typeIn
   const results = {
     typeName,
     valid: true,
-    error: "",
+    error: getNoErrorDescriptor(),
     errorMap: {}
   };
   const { fields = {}, tags = {} } = typeInfo;
   const { deniedOperations: { [typeOperation]: denied = false } = {} } = tags;
   if (denied) {
     results.valid = false;
-    results.error = DENIED_TYPE_OPERATIONS[typeOperation];
+    results.error = getErrorDescriptor(DENIED_TYPE_OPERATIONS[typeOperation]);
   } else {
     for (const vF of valueFields) {
       const vFieldInfo = fields[vF];
@@ -260,12 +368,75 @@ var validateTypeOperationAllowed = (typeName, valueFields, typeOperation, typeIn
   }
   return results;
 };
+var TYPE_INFO_DATA_ITEM_TYPE_NAME = "__TYPE_INFO_DATA_ITEM__";
+var validateTypeInfoDataItem = (value = {}, typeInfo, customValidatorMap = {}, options) => {
+  const {
+    typeName = TYPE_INFO_DATA_ITEM_TYPE_NAME,
+    typeInfoMap = {},
+    strict = true,
+    customTypeValidators,
+    typeOperation = "CREATE" /* CREATE */,
+    relationshipValidationType = "STRICT_EXCLUDE" /* STRICT_EXCLUDE */,
+    itemIsPartial = typeOperation === "UPDATE" /* UPDATE */,
+    validateHidden = false,
+    validateReadonly = false
+  } = options ?? {};
+  const sourceFields = typeInfo.fields ?? {};
+  const normalizedFields = {};
+  for (const [fieldName, field] of Object.entries(sourceFields)) {
+    const validationTags = field.tags?.validation ?? {};
+    const shouldValidateHidden = validationTags.validateHidden ?? validateHidden;
+    const shouldValidateReadonly = validationTags.validateReadonly ?? validateReadonly;
+    const shouldSkipRequiredChecks = field.tags?.hidden && !shouldValidateHidden || field.readonly && !shouldValidateReadonly;
+    normalizedFields[fieldName] = shouldSkipRequiredChecks ? {
+      ...field,
+      optional: true
+    } : field;
+  }
+  const normalizedTypeInfo = {
+    ...typeInfo,
+    fields: normalizedFields
+  };
+  const results = validateTypeInfoValue(
+    value ?? {},
+    typeName,
+    { ...typeInfoMap, [typeName]: normalizedTypeInfo },
+    strict,
+    customTypeValidators,
+    typeOperation,
+    relationshipValidationType,
+    itemIsPartial
+  );
+  for (const [fieldName, validator] of Object.entries(customValidatorMap)) {
+    const field = normalizedFields[fieldName];
+    if (!field) {
+      continue;
+    }
+    let error = getNoErrorDescriptor();
+    try {
+      error = validator(value[fieldName], field);
+    } catch (e) {
+      error = getErrorDescriptor(ERROR_MESSAGE_CONSTANTS.INVALID_CUSTOM_TYPE);
+    }
+    if (error.code !== ERROR_MESSAGE_CONSTANTS.NONE) {
+      results.valid = false;
+      results.errorMap[fieldName] = [
+        ...results.errorMap[fieldName] ?? [],
+        error
+      ];
+      if (results.error.code === ERROR_MESSAGE_CONSTANTS.NONE) {
+        results.error = error;
+      }
+    }
+  }
+  return results;
+};
 var validateTypeInfoValue = (value, typeInfoFullName, typeInfoMap, strict = false, customValidators, typeOperation, relationshipValidationType, itemIsPartial) => {
   const typeInfo = typeInfoMap[typeInfoFullName];
   const results = {
     typeName: typeInfoFullName,
     valid: !!typeInfo,
-    error: !!typeInfo ? "" : ERROR_MESSAGE_CONSTANTS.TYPE_DOES_NOT_EXIST,
+    error: !!typeInfo ? getNoErrorDescriptor() : getErrorDescriptor(ERROR_MESSAGE_CONSTANTS.TYPE_DOES_NOT_EXIST),
     errorMap: {}
   };
   if (typeInfo) {
@@ -288,7 +459,7 @@ var validateTypeInfoValue = (value, typeInfoFullName, typeInfoMap, strict = fals
         const existingError = results.errorMap[oE] ?? [];
         results.errorMap[oE] = existingError ? [...existingError, ...operationErrorMap[oE]] : operationErrorMap[oE];
       }
-      if (!operationValid && operationError) {
+      if (!operationValid && operationError.code !== ERROR_MESSAGE_CONSTANTS.NONE) {
         results.error = operationError;
       }
     }
@@ -303,7 +474,9 @@ var validateTypeInfoValue = (value, typeInfoFullName, typeInfoMap, strict = fals
       }
       if (!valid) {
         results.valid = false;
-        results.error = ERROR_MESSAGE_CONSTANTS.NO_UNION_TYPE_MATCHED;
+        results.error = getErrorDescriptor(
+          ERROR_MESSAGE_CONSTANTS.NO_UNION_TYPE_MATCHED
+        );
       }
     } else if (strict) {
       const knownFields = Object.keys(fields || {});
@@ -311,7 +484,9 @@ var validateTypeInfoValue = (value, typeInfoFullName, typeInfoMap, strict = fals
       for (const vF of valueFields) {
         if (!knownFields.includes(vF)) {
           results.valid = false;
-          results.errorMap[vF] = [ERROR_MESSAGE_CONSTANTS.INVALID_FIELD];
+          results.errorMap[vF] = [
+            getErrorDescriptor(ERROR_MESSAGE_CONSTANTS.INVALID_FIELD)
+          ];
         }
       }
     }
@@ -336,18 +511,28 @@ var validateTypeInfoValue = (value, typeInfoFullName, typeInfoMap, strict = fals
             itemIsPartial
           );
           results.valid = getValidityValue(results.valid, fieldValid);
-          results.errorMap[key] = [fieldError];
-          for (const fE in fieldErrorMap) {
-            results.errorMap[getPathString([key, fE])] = fieldErrorMap[fE];
+          const fieldEntries = [fieldError];
+          const arrayItemErrorMap = getArrayItemErrorMap(
+            fieldErrorMap[ARRAY_ITEM_ERROR_MAP_KEY]
+          );
+          if (Object.keys(arrayItemErrorMap).length) {
+            fieldEntries.push({ itemErrorMap: arrayItemErrorMap });
+          }
+          results.errorMap[key] = fieldEntries;
+          for (const [fE, entries] of Object.entries(fieldErrorMap)) {
+            if (fE === ARRAY_ITEM_ERROR_MAP_KEY) {
+              continue;
+            }
+            results.errorMap[getPathString([key, fE])] = entries;
           }
         }
       }
     }
-    if (!results.valid && !results.error) {
-      results.error = ERROR_MESSAGE_CONSTANTS.INVALID_TYPE;
+    if (!results.valid && results.error.code === ERROR_MESSAGE_CONSTANTS.NONE) {
+      results.error = getErrorDescriptor(ERROR_MESSAGE_CONSTANTS.INVALID_TYPE);
     }
   }
   return results;
 };
 
-export { DENIED_TYPE_OPERATIONS, ERROR_MESSAGE_CONSTANTS, INVALID_CUSTOM_TYPE, PRIMITIVE_ERROR_MESSAGE_CONSTANTS, RelationshipValidationType, TYPE_KEYWORD_VALIDATORS, getValidityValue, hasValue, validateArrayOfTypeInfoFieldValues, validateCustomType, validateKeywordType, validateTypeInfoFieldOperationAllowed, validateTypeInfoFieldValue, validateTypeInfoValue, validateTypeOperationAllowed, validateValueMatchesPattern };
+export { DENIED_TYPE_OPERATIONS, ERROR_MESSAGE_CONSTANTS, INVALID_CUSTOM_TYPE, PRIMITIVE_ERROR_MESSAGE_CONSTANTS, RelationshipValidationType, TYPE_KEYWORD_ERROR_MESSAGE_CONSTANTS, TYPE_KEYWORD_VALIDATORS, TypeOperation, getArrayItemErrorMap, getErrorDescriptor, getErrorDescriptors, getNoErrorDescriptor, getValidityValue, hasValue, isArrayErrorDescriptorCollection, validateArrayOfTypeInfoFieldValues, validateCustomType, validateKeywordType, validateTypeInfoDataItem, validateTypeInfoFieldOperationAllowed, validateTypeInfoFieldValue, validateTypeInfoValue, validateTypeOperationAllowed, validateValueMatchesPattern };