@remoteoss/json-schema-form 0.6.1-beta.0 → 0.6.4-beta.0

package/CHANGELOG.md

@@ -1,3 +1,11 @@
+#### 0.6.4-beta.0 (2023-09-15)
+
+
+
+##### Changes
+
+*  Inline rule handling for computedAttrs ([#40](https://github.com/remoteoss/json-schema-form/pull/40)) ([860ad91b](https://github.com/remoteoss/json-schema-form/commit/860ad91b034ab35d4d4bc51c0c04675f102bf278))
+
 #### 0.6.1-beta.0 (2023-09-13)
 
 ##### Changes

package/dist/index.cjs

@@ -1,8 +1,8 @@
 
 /*!
  Copyright (c) 2023 Remote Technology, Inc.
- NPM Package: @remoteoss/json-schema-form@0.6.1-beta.0
- Generated: Wed, 13 Sep 2023 09:54:37 GMT
+ NPM Package: @remoteoss/json-schema-form@0.6.4-beta.0
+ Generated: Fri, 15 Sep 2023 12:36:13 GMT
 
  MIT License
 
@@ -527,7 +527,7 @@ function replaceHandlebarsTemplates({
       throw Error("Cannot define multiple rules without a template string with key `value`.");
     }
     const computedTemplateValue = Object.entries(rules).reduce((prev, [key, rule]) => {
-      const computedValue = logic.getScope(parentID).evaluateValidation(rule, formValues);
+      const computedValue = logic.getScope(parentID).validate(rule, formValues);
       return prev.replaceAll(`{{${key}}}`, computedValue);
     }, value);
     return computedTemplateValue.replace(/\{\{([^{}]+)\}\}/g, (match, key) => {
@@ -577,8 +577,12 @@ function handleComputedAttribute(logic, formValues, parentID, name) {
         ];
       }
       case "const":
-      default:
+      default: {
+        if (typeof value === "object" && value.rule) {
+          return [key, logic.getScope(parentID).validate(value.rule, formValues)];
+        }
         return [key, logic.getScope(parentID).applyComputedValueInField(value, formValues, name)];
+      }
     }
   };
 }

package/dist/index.js

@@ -1,8 +1,8 @@
 
 /*!
  Copyright (c) 2023 Remote Technology, Inc.
- NPM Package: @remoteoss/json-schema-form@0.6.1-beta.0
- Generated: Wed, 13 Sep 2023 09:54:37 GMT
+ NPM Package: @remoteoss/json-schema-form@0.6.4-beta.0
+ Generated: Fri, 15 Sep 2023 12:36:13 GMT
 
  MIT License
 
@@ -491,7 +491,7 @@ function replaceHandlebarsTemplates({
       throw Error("Cannot define multiple rules without a template string with key `value`.");
     }
     const computedTemplateValue = Object.entries(rules).reduce((prev, [key, rule]) => {
-      const computedValue = logic.getScope(parentID).evaluateValidation(rule, formValues);
+      const computedValue = logic.getScope(parentID).validate(rule, formValues);
       return prev.replaceAll(`{{${key}}}`, computedValue);
     }, value);
     return computedTemplateValue.replace(/\{\{([^{}]+)\}\}/g, (match, key) => {
@@ -541,8 +541,12 @@ function handleComputedAttribute(logic, formValues, parentID, name) {
         ];
       }
       case "const":
-      default:
+      default: {
+        if (typeof value === "object" && value.rule) {
+          return [key, logic.getScope(parentID).validate(value.rule, formValues)];
+        }
         return [key, logic.getScope(parentID).applyComputedValueInField(value, formValues, name)];
+      }
     }
   };
 }

package/dist/standalone.js

@@ -1,8 +1,8 @@
 
 /*!
  Copyright (c) 2023 Remote Technology, Inc.
- NPM Package: @remoteoss/json-schema-form@0.6.1-beta.0
- Generated: Wed, 13 Sep 2023 09:54:37 GMT
+ NPM Package: @remoteoss/json-schema-form@0.6.4-beta.0
+ Generated: Fri, 15 Sep 2023 12:36:13 GMT
 
  MIT License
 
@@ -11845,7 +11845,7 @@ function replaceHandlebarsTemplates({
       throw Error("Cannot define multiple rules without a template string with key `value`.");
     }
     const computedTemplateValue = Object.entries(rules).reduce((prev, [key, rule]) => {
-      const computedValue = logic.getScope(parentID).evaluateValidation(rule, formValues);
+      const computedValue = logic.getScope(parentID).validate(rule, formValues);
       return prev.replaceAll(`{{${key}}}`, computedValue);
     }, value);
     return computedTemplateValue.replace(/\{\{([^{}]+)\}\}/g, (match, key) => {
@@ -11895,8 +11895,12 @@ function handleComputedAttribute(logic, formValues, parentID, name) {
         ];
       }
       case "const":
-      default:
+      default: {
+        if (typeof value === "object" && value.rule) {
+          return [key, logic.getScope(parentID).validate(value.rule, formValues)];
+        }
         return [key, logic.getScope(parentID).applyComputedValueInField(value, formValues, name)];
+      }
     }
   };
 }

package/package.json

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

package/src/tests/jsonLogic.fixtures.js

@@ -439,3 +439,115 @@ export const schemaWithBadOperation = {
     },
   },
 };
+
+export const schemaWithInlineRuleForComputedAttributeWithCopy = {
+  properties: {
+    field_a: {
+      type: 'number',
+    },
+    field_b: {
+      type: 'number',
+      'x-jsf-logic-computedAttrs': {
+        title: {
+          value: 'I need this to work using the {{rule}}.',
+          rule: {
+            '+': [{ var: 'field_a' }, 10],
+          },
+        },
+      },
+    },
+  },
+};
+
+export const schemaWithInlineMultipleRulesForComputedAttributes = {
+  properties: {
+    field_a: {
+      type: 'number',
+    },
+    field_b: {
+      type: 'number',
+      'x-jsf-logic-computedAttrs': {
+        description: {
+          value: 'Must be between {{half_a}} and {{double_a}}.',
+          half_a: {
+            '/': [{ var: 'field_a' }, 2],
+          },
+          double_a: {
+            '*': [{ var: 'field_a' }, 2],
+          },
+        },
+      },
+    },
+  },
+};
+
+export const schemaInlineComputedAttrForTitle = {
+  properties: {
+    field_a: {
+      type: 'number',
+    },
+    field_b: {
+      type: 'number',
+      'x-jsf-logic-computedAttrs': {
+        title: {
+          value: '{{rule}}',
+          rule: {
+            '+': [{ var: 'field_a' }, 10],
+          },
+        },
+      },
+    },
+  },
+};
+
+export const schemaInlineComputedAttrForMaximumMinimumValues = {
+  properties: {
+    field_a: {
+      type: 'number',
+      default: 0,
+    },
+    field_b: {
+      type: 'number',
+      'x-jsf-logic-computedAttrs': {
+        maximum: {
+          rule: {
+            '+': [{ var: 'field_a' }, 10],
+          },
+        },
+        minimum: {
+          rule: {
+            '-': [{ var: 'field_a' }, 10],
+          },
+        },
+      },
+    },
+  },
+};
+
+export const schemaWithJSFLogicAndInlineRule = {
+  properties: {
+    field_a: {
+      type: 'number',
+    },
+    field_b: {
+      type: 'number',
+      'x-jsf-logic-computedAttrs': {
+        title: {
+          value: 'Going to use {{rule}} and {{not_inline}}',
+          rule: {
+            '+': [{ var: 'field_a' }, 10],
+          },
+        },
+      },
+    },
+  },
+  'x-jsf-logic': {
+    computedValues: {
+      not_inline: {
+        rule: {
+          '+': [1, 3],
+        },
+      },
+    },
+  },
+};

package/src/tests/jsonLogic.test.js

@@ -4,6 +4,8 @@ import {
   createSchemaWithRulesOnFieldA,
   createSchemaWithThreePropertiesWithRuleOnFieldA,
   multiRuleSchema,
+  schemaInlineComputedAttrForMaximumMinimumValues,
+  schemaInlineComputedAttrForTitle,
   schemaWithBadOperation,
   schemaWithComputedAttributeThatDoesntExist,
   schemaWithComputedAttributeThatDoesntExistDescription,
@@ -12,7 +14,10 @@ import {
   schemaWithComputedAttributesAndErrorMessages,
   schemaWithDeepVarThatDoesNotExist,
   schemaWithDeepVarThatDoesNotExistOnFieldset,
+  schemaWithInlineMultipleRulesForComputedAttributes,
+  schemaWithInlineRuleForComputedAttributeWithCopy,
   schemaWithInlinedRuleOnComputedAttributeThatReferencesUnknownVar,
+  schemaWithJSFLogicAndInlineRule,
   schemaWithMissingComputedValue,
   schemaWithMissingRule,
   schemaWithNativeAndJSONLogicChecks,
@@ -344,5 +349,72 @@ describe('jsonLogic: cross-values validations', () => {
       expect(fieldB.maximum).toEqual(8);
       expect(fieldB.statement).toEqual({ description: 'Must be bigger than 4 and smaller than 8' });
     });
+
+    it('Use a inline-rule in a schema for a title attribute', () => {
+      const { fields, handleValidation } = createHeadlessForm(
+        schemaWithInlineRuleForComputedAttributeWithCopy,
+        {
+          strictInputType: false,
+        }
+      );
+      const [, fieldB] = fields;
+      expect(handleValidation({ field_a: 0, field_b: null }).formErrors).toEqual(undefined);
+      expect(fieldB.label).toEqual('I need this to work using the 10.');
+      expect(handleValidation({ field_a: 10 }).formErrors).toEqual(undefined);
+      expect(fieldB.label).toEqual('I need this to work using the 20.');
+    });
+  });
+
+  it('Use multiple inline rules with different identifiers', () => {
+    const { fields, handleValidation } = createHeadlessForm(
+      schemaWithInlineMultipleRulesForComputedAttributes,
+      {
+        strictInputType: false,
+      }
+    );
+    const [, fieldB] = fields;
+    expect(handleValidation({ field_a: 10, field_b: null }).formErrors).toEqual(undefined);
+    expect(fieldB.description).toEqual('Must be between 5 and 20.');
+  });
+
+  it('Use an inline rule in a schema for a title but it just uses the value', () => {
+    const { fields, handleValidation } = createHeadlessForm(schemaInlineComputedAttrForTitle, {
+      strictInputType: false,
+    });
+    const [, fieldB] = fields;
+    expect(handleValidation({ field_a: 10, field_b: null }).formErrors).toEqual(undefined);
+    expect(fieldB.label).toEqual('20');
+  });
+
+  it('Use an inline rule for a minimum, maximum value', () => {
+    const { fields, handleValidation } = createHeadlessForm(
+      schemaInlineComputedAttrForMaximumMinimumValues,
+      {
+        strictInputType: false,
+      }
+    );
+    const [, fieldB] = fields;
+    expect(fieldB).toMatchObject({ minimum: -10, maximum: 10 });
+    expect(handleValidation({ field_a: 10, field_b: null }).formErrors).toBeUndefined();
+    expect(fieldB).toMatchObject({ minimum: 0, maximum: 20 });
+    expect(handleValidation({ field_a: 50, field_b: 20 }).formErrors).toEqual({
+      field_b: 'Must be greater or equal to 40',
+    });
+    expect(fieldB).toMatchObject({ minimum: 40, maximum: 60 });
+    expect(handleValidation({ field_a: 50, field_b: 70 }).formErrors).toEqual({
+      field_b: 'Must be smaller or equal to 60',
+    });
+    expect(fieldB).toMatchObject({ minimum: 40, maximum: 60 });
+    expect(handleValidation({ field_a: 50, field_b: 50 }).formErrors).toBeUndefined();
+    expect(fieldB).toMatchObject({ minimum: 40, maximum: 60 });
+  });
+
+  it('Mix use of multiple inline rules and an external rule', () => {
+    const { fields, handleValidation } = createHeadlessForm(schemaWithJSFLogicAndInlineRule, {
+      strictInputType: false,
+    });
+    handleValidation({ field_a: 10 });
+    const [, fieldB] = fields;
+    expect(fieldB.label).toEqual('Going to use 20 and 4');
   });
 });