@remoteoss/json-schema-form 0.10.1-beta.0 → 0.11.0-beta.0

package/dist/standalone.js

@@ -1,8 +1,8 @@
 
 /*!
  Copyright (c) 2024 Remote Technology, Inc.
- NPM Package: @remoteoss/json-schema-form@0.10.1-beta.0
- Generated: Tue, 23 Jul 2024 21:13:09 GMT
+ NPM Package: @remoteoss/json-schema-form@0.11.0-beta.0
+ Generated: Thu, 25 Jul 2024 16:43:12 GMT
 
  MIT License
 
@@ -2524,9 +2524,9 @@ var require_mapToArray = __commonJS({
 // node_modules/lodash/_setToArray.js
 var require_setToArray = __commonJS({
   "node_modules/lodash/_setToArray.js"(exports2, module2) {
-    function setToArray2(set2) {
-      var index = -1, result = Array(set2.size);
-      set2.forEach(function(value) {
+    function setToArray2(set3) {
+      var index = -1, result = Array(set3.size);
+      set3.forEach(function(value) {
         result[++index] = value;
       });
       return result;
@@ -3489,10 +3489,10 @@ var require_merge = __commonJS({
 var require_set = __commonJS({
   "node_modules/lodash/set.js"(exports2, module2) {
     var baseSet = require_baseSet();
-    function set2(object2, path, value) {
+    function set3(object2, path, value) {
       return object2 == null ? object2 : baseSet(object2, path, value);
     }
-    module2.exports = set2;
+    module2.exports = set3;
   }
 });
 
@@ -6862,6 +6862,168 @@ var require_mapValues = __commonJS({
   }
 });
 
+// node_modules/lodash/_arrayIncludesWith.js
+var require_arrayIncludesWith = __commonJS({
+  "node_modules/lodash/_arrayIncludesWith.js"(exports2, module2) {
+    function arrayIncludesWith(array2, value, comparator) {
+      var index = -1, length2 = array2 == null ? 0 : array2.length;
+      while (++index < length2) {
+        if (comparator(value, array2[index])) {
+          return true;
+        }
+      }
+      return false;
+    }
+    module2.exports = arrayIncludesWith;
+  }
+});
+
+// node_modules/lodash/_baseDifference.js
+var require_baseDifference = __commonJS({
+  "node_modules/lodash/_baseDifference.js"(exports2, module2) {
+    var SetCache2 = require_SetCache();
+    var arrayIncludes = require_arrayIncludes();
+    var arrayIncludesWith = require_arrayIncludesWith();
+    var arrayMap2 = require_arrayMap();
+    var baseUnary2 = require_baseUnary();
+    var cacheHas2 = require_cacheHas();
+    var LARGE_ARRAY_SIZE2 = 200;
+    function baseDifference(array2, values2, iteratee, comparator) {
+      var index = -1, includes = arrayIncludes, isCommon = true, length2 = array2.length, result = [], valuesLength = values2.length;
+      if (!length2) {
+        return result;
+      }
+      if (iteratee) {
+        values2 = arrayMap2(values2, baseUnary2(iteratee));
+      }
+      if (comparator) {
+        includes = arrayIncludesWith;
+        isCommon = false;
+      } else if (values2.length >= LARGE_ARRAY_SIZE2) {
+        includes = cacheHas2;
+        isCommon = false;
+        values2 = new SetCache2(values2);
+      }
+      outer:
+        while (++index < length2) {
+          var value = array2[index], computed = iteratee == null ? value : iteratee(value);
+          value = comparator || value !== 0 ? value : 0;
+          if (isCommon && computed === computed) {
+            var valuesIndex = valuesLength;
+            while (valuesIndex--) {
+              if (values2[valuesIndex] === computed) {
+                continue outer;
+              }
+            }
+            result.push(value);
+          } else if (!includes(values2, computed, comparator)) {
+            result.push(value);
+          }
+        }
+      return result;
+    }
+    module2.exports = baseDifference;
+  }
+});
+
+// node_modules/lodash/difference.js
+var require_difference = __commonJS({
+  "node_modules/lodash/difference.js"(exports2, module2) {
+    var baseDifference = require_baseDifference();
+    var baseFlatten = require_baseFlatten();
+    var baseRest = require_baseRest();
+    var isArrayLikeObject = require_isArrayLikeObject();
+    var difference2 = baseRest(function(array2, values2) {
+      return isArrayLikeObject(array2) ? baseDifference(array2, baseFlatten(values2, 1, isArrayLikeObject, true)) : [];
+    });
+    module2.exports = difference2;
+  }
+});
+
+// node_modules/lodash/_baseIntersection.js
+var require_baseIntersection = __commonJS({
+  "node_modules/lodash/_baseIntersection.js"(exports2, module2) {
+    var SetCache2 = require_SetCache();
+    var arrayIncludes = require_arrayIncludes();
+    var arrayIncludesWith = require_arrayIncludesWith();
+    var arrayMap2 = require_arrayMap();
+    var baseUnary2 = require_baseUnary();
+    var cacheHas2 = require_cacheHas();
+    var nativeMin = Math.min;
+    function baseIntersection(arrays, iteratee, comparator) {
+      var includes = comparator ? arrayIncludesWith : arrayIncludes, length2 = arrays[0].length, othLength = arrays.length, othIndex = othLength, caches = Array(othLength), maxLength = Infinity, result = [];
+      while (othIndex--) {
+        var array2 = arrays[othIndex];
+        if (othIndex && iteratee) {
+          array2 = arrayMap2(array2, baseUnary2(iteratee));
+        }
+        maxLength = nativeMin(array2.length, maxLength);
+        caches[othIndex] = !comparator && (iteratee || length2 >= 120 && array2.length >= 120) ? new SetCache2(othIndex && array2) : void 0;
+      }
+      array2 = arrays[0];
+      var index = -1, seen = caches[0];
+      outer:
+        while (++index < length2 && result.length < maxLength) {
+          var value = array2[index], computed = iteratee ? iteratee(value) : value;
+          value = comparator || value !== 0 ? value : 0;
+          if (!(seen ? cacheHas2(seen, computed) : includes(result, computed, comparator))) {
+            othIndex = othLength;
+            while (--othIndex) {
+              var cache = caches[othIndex];
+              if (!(cache ? cacheHas2(cache, computed) : includes(arrays[othIndex], computed, comparator))) {
+                continue outer;
+              }
+            }
+            if (seen) {
+              seen.push(computed);
+            }
+            result.push(value);
+          }
+        }
+      return result;
+    }
+    module2.exports = baseIntersection;
+  }
+});
+
+// node_modules/lodash/_castArrayLikeObject.js
+var require_castArrayLikeObject = __commonJS({
+  "node_modules/lodash/_castArrayLikeObject.js"(exports2, module2) {
+    var isArrayLikeObject = require_isArrayLikeObject();
+    function castArrayLikeObject(value) {
+      return isArrayLikeObject(value) ? value : [];
+    }
+    module2.exports = castArrayLikeObject;
+  }
+});
+
+// node_modules/lodash/intersection.js
+var require_intersection = __commonJS({
+  "node_modules/lodash/intersection.js"(exports2, module2) {
+    var arrayMap2 = require_arrayMap();
+    var baseIntersection = require_baseIntersection();
+    var baseRest = require_baseRest();
+    var castArrayLikeObject = require_castArrayLikeObject();
+    var intersection2 = baseRest(function(arrays) {
+      var mapped = arrayMap2(arrays, castArrayLikeObject);
+      return mapped.length && mapped[0] === arrays[0] ? baseIntersection(mapped) : [];
+    });
+    module2.exports = intersection2;
+  }
+});
+
+// node_modules/lodash/mergeWith.js
+var require_mergeWith = __commonJS({
+  "node_modules/lodash/mergeWith.js"(exports2, module2) {
+    var baseMerge = require_baseMerge();
+    var createAssigner = require_createAssigner();
+    var mergeWith2 = createAssigner(function(object2, source, srcIndex, customizer) {
+      baseMerge(object2, source, srcIndex, customizer);
+    });
+    module2.exports = mergeWith2;
+  }
+});
+
 // src/createHeadlessForm.js
 var import_get4 = __toESM(require_get());
 var import_isNil3 = __toESM(require_isNil());
@@ -8316,9 +8478,9 @@ function mapToArray(map) {
 var mapToArray_default = mapToArray;
 
 // node_modules/lodash-es/_setToArray.js
-function setToArray(set2) {
-  var index = -1, result = Array(set2.size);
-  set2.forEach(function(value) {
+function setToArray(set3) {
+  var index = -1, result = Array(set3.size);
+  set3.forEach(function(value) {
     result[++index] = value;
   });
   return result;
@@ -13151,37 +13313,78 @@ function createHeadlessForm(jsonSchema, customConfig = {}) {
 }
 
 // src/modify.js
+var import_difference = __toESM(require_difference());
 var import_get5 = __toESM(require_get());
+var import_intersection = __toESM(require_intersection());
 var import_merge3 = __toESM(require_merge());
+var import_mergeWith = __toESM(require_mergeWith());
+var import_set2 = __toESM(require_set());
+var WARNING_TYPES = {
+  FIELD_TO_CHANGE_NOT_FOUND: "FIELD_TO_CHANGE_NOT_FOUND",
+  ORDER_MISSING_FIELDS: "ORDER_MISSING_FIELDS",
+  FIELD_TO_CREATE_EXISTS: "FIELD_TO_CREATE_EXISTS",
+  PICK_MISSED_FIELD: "PICK_MISSED_FIELD"
+};
 function shortToFullPath(path) {
   return path.replace(".", ".properties.");
 }
+function mergeReplaceArray(_, newVal) {
+  return Array.isArray(newVal) ? newVal : void 0;
+}
 function standardizeAttrs(attrs) {
-  const { errorMessage, properties, ...rest } = attrs;
+  const { errorMessage, presentation, properties, ...rest } = attrs;
   return {
     ...rest,
+    ...presentation ? { "x-jsf-presentation": presentation } : {},
     ...errorMessage ? { "x-jsf-errorMessage": errorMessage } : {}
   };
 }
+function isConditionalReferencingAnyPickedField(condition, fieldsToPick) {
+  const { if: ifCondition, then: thenCondition, else: elseCondition } = condition;
+  const inIf = (0, import_intersection.default)(ifCondition.required, fieldsToPick);
+  if (inIf.length > 0) {
+    return true;
+  }
+  const inThen = (0, import_intersection.default)(thenCondition.required, fieldsToPick) || (0, import_intersection.default)(Object.keys(thenCondition.properties), fieldsToPick);
+  if (inThen.length > 0) {
+    return true;
+  }
+  const inElse = (0, import_intersection.default)(elseCondition.required, fieldsToPick) || (0, import_intersection.default)(Object.keys(elseCondition.properties), fieldsToPick);
+  if (inElse.length > 0) {
+    return true;
+  }
+  return false;
+}
 function rewriteFields(schema, fieldsConfig) {
   if (!fieldsConfig)
-    return null;
+    return { warnings: null };
+  const warnings = [];
   const fieldsToModify = Object.entries(fieldsConfig);
   fieldsToModify.forEach(([shortPath, mutation]) => {
     const fieldPath = shortToFullPath(shortPath);
     if (!(0, import_get5.default)(schema.properties, fieldPath)) {
+      warnings.push({
+        type: WARNING_TYPES.FIELD_TO_CHANGE_NOT_FOUND,
+        message: `Changing field "${shortPath}" was ignored because it does not exist.`
+      });
       return;
     }
     const fieldAttrs = (0, import_get5.default)(schema.properties, fieldPath);
     const fieldChanges = typeof mutation === "function" ? mutation(fieldAttrs) : mutation;
-    (0, import_merge3.default)((0, import_get5.default)(schema.properties, fieldPath), {
-      ...fieldAttrs,
-      ...standardizeAttrs(fieldChanges)
-    });
+    (0, import_mergeWith.default)(
+      (0, import_get5.default)(schema.properties, fieldPath),
+      {
+        ...fieldAttrs,
+        ...standardizeAttrs(fieldChanges)
+      },
+      mergeReplaceArray
+    );
     if (fieldChanges.properties) {
-      rewriteFields((0, import_get5.default)(schema.properties, fieldPath), fieldChanges.properties);
+      const result = rewriteFields((0, import_get5.default)(schema.properties, fieldPath), fieldChanges.properties);
+      warnings.push(result.warnings);
     }
   });
+  return { warnings: warnings.flat() };
 }
 function rewriteAllFields(schema, configCallback, context) {
   if (!configCallback)
@@ -13189,10 +13392,14 @@ function rewriteAllFields(schema, configCallback, context) {
   const parentName = context?.parent;
   Object.entries(schema.properties).forEach(([fieldName, fieldAttrs]) => {
     const fullName = parentName ? `${parentName}.${fieldName}` : fieldName;
-    (0, import_merge3.default)((0, import_get5.default)(schema.properties, fieldName), {
-      ...fieldAttrs,
-      ...configCallback(fullName, fieldAttrs)
-    });
+    (0, import_mergeWith.default)(
+      (0, import_get5.default)(schema.properties, fieldName),
+      {
+        ...fieldAttrs,
+        ...configCallback(fullName, fieldAttrs)
+      },
+      mergeReplaceArray
+    );
     if (fieldAttrs.properties) {
       rewriteAllFields(fieldAttrs, configCallback, {
         parent: fieldName
@@ -13200,11 +13407,154 @@ function rewriteAllFields(schema, configCallback, context) {
     }
   });
 }
+function reorderFields(schema, configOrder) {
+  if (!configOrder)
+    return { warnings: null };
+  const warnings = [];
+  const originalOrder = schema["x-jsf-order"] || [];
+  const orderConfig = typeof configOrder === "function" ? configOrder(originalOrder) : configOrder;
+  const remaining = (0, import_difference.default)(originalOrder, orderConfig);
+  if (remaining.length > 0) {
+    warnings.push({
+      type: WARNING_TYPES.ORDER_MISSING_FIELDS,
+      message: `Some fields got forgotten in the new order. They were automatically appended: ${remaining.join(
+        ", "
+      )}`
+    });
+  }
+  schema["x-jsf-order"] = [...orderConfig, ...remaining];
+  return { warnings };
+}
+function createFields(schema, fieldsConfig) {
+  if (!fieldsConfig)
+    return { warnings: null };
+  const warnings = [];
+  const fieldsToCreate = Object.entries(fieldsConfig);
+  fieldsToCreate.forEach(([shortPath, fieldAttrs]) => {
+    const fieldPath = shortToFullPath(shortPath);
+    if (fieldAttrs.properties) {
+      const result = createFields((0, import_get5.default)(schema.properties, fieldPath), fieldAttrs.properties);
+      warnings.push(result.warnings);
+    }
+    const fieldInSchema = (0, import_get5.default)(schema.properties, fieldPath);
+    if (fieldInSchema) {
+      warnings.push({
+        type: WARNING_TYPES.FIELD_TO_CREATE_EXISTS,
+        message: `Creating field "${shortPath}" was ignored because it already exists.`
+      });
+      return;
+    }
+    const fieldInObjectPath = (0, import_set2.default)({}, fieldPath, standardizeAttrs(fieldAttrs));
+    (0, import_merge3.default)(schema.properties, fieldInObjectPath);
+  });
+  return { warnings: warnings.flat() };
+}
+function pickFields(originalSchema, fieldsToPick) {
+  if (!fieldsToPick) {
+    return { schema: originalSchema, warnings: null };
+  }
+  const newSchema = {
+    properties: {}
+  };
+  Object.entries(originalSchema).forEach(([attrKey, attrValue]) => {
+    switch (attrKey) {
+      case "properties":
+        fieldsToPick.forEach((fieldPath) => {
+          (0, import_set2.default)(newSchema.properties, fieldPath, attrValue[fieldPath]);
+        });
+        break;
+      case "x-jsf-order":
+      case "required":
+        newSchema[attrKey] = attrValue.filter((fieldName) => fieldsToPick.includes(fieldName));
+        break;
+      case "allOf": {
+        const newAllOf = originalSchema.allOf.filter(
+          (condition) => isConditionalReferencingAnyPickedField(condition, fieldsToPick)
+        );
+        newSchema[attrKey] = newAllOf;
+        break;
+      }
+      default:
+        newSchema[attrKey] = attrValue;
+    }
+  });
+  let missingFields = {};
+  newSchema.allOf.forEach((condition) => {
+    const { if: ifCondition, then: thenCondition, else: elseCondition } = condition;
+    const index = originalSchema.allOf.indexOf(condition);
+    missingFields = {
+      ...missingFields,
+      ...findMissingFields(ifCondition, {
+        fields: fieldsToPick,
+        path: `allOf[${index}].if`
+      }),
+      ...findMissingFields(thenCondition, {
+        fields: fieldsToPick,
+        path: `allOf[${index}].then`
+      }),
+      ...findMissingFields(elseCondition, {
+        fields: fieldsToPick,
+        path: `allOf[${index}].else`
+      })
+    };
+  });
+  const warnings = [];
+  if (Object.keys(missingFields).length > 0) {
+    Object.entries(missingFields).forEach(([fieldName]) => {
+      (0, import_set2.default)(newSchema.properties, fieldName, originalSchema.properties[fieldName]);
+    });
+    warnings.push({
+      type: WARNING_TYPES.PICK_MISSED_FIELD,
+      message: `The picked fields are in conditionals that refeer other fields. They added automatically: ${Object.keys(
+        missingFields
+      ).map((name) => `"${name}"`).join(", ")}. Check "meta" for more details.`,
+      meta: missingFields
+    });
+  }
+  return { schema: newSchema, warnings };
+}
+function findMissingFields(conditional, { fields, path }) {
+  if (!conditional) {
+    return null;
+  }
+  let missingFields = {};
+  conditional.required?.forEach((fieldName) => {
+    if (!fields.includes(fieldName)) {
+      missingFields[fieldName] = {
+        path
+      };
+    }
+  });
+  Object.entries(conditional.properties || []).forEach(([fieldName]) => {
+    if (!fields.includes(fieldName)) {
+      missingFields[fieldName] = { path };
+    }
+  });
+  return missingFields;
+}
 function modify(originalSchema, config) {
   const schema = JSON.parse(JSON.stringify(originalSchema));
-  rewriteFields(schema, config.fields);
+  const resultRewrite = rewriteFields(schema, config.fields);
   rewriteAllFields(schema, config.allFields);
-  return schema;
+  const resultCreate = createFields(schema, config.create);
+  const resultPick = pickFields(schema, config.pick);
+  const finalSchema = resultPick.schema;
+  const resultReorder = reorderFields(finalSchema, config.orderRoot);
+  if (!config.muteLogging) {
+    console.warn(
+      "json-schema-form modify(): We highly recommend you to handle/report the returned `warnings` as they highlight possible bugs in your modifications. To mute this log, pass `muteLogging: true` to the config."
+    );
+  }
+  const warnings = [
+    resultRewrite.warnings,
+    resultCreate.warnings,
+    resultPick.warnings,
+    resultReorder.warnings
+  ].flat().filter(Boolean);
+  return {
+    schema: finalSchema,
+    warnings
+  };
 }
 export {
   buildCompleteYupSchema,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remoteoss/json-schema-form",
-  "version": "0.10.1-beta.0",
+  "version": "0.11.0-beta.0",
   "description": "Headless UI form powered by JSON Schemas",
   "author": "Remote.com <engineering@remote.com> (https://remote.com/)",
   "license": "MIT",