@jsonforms/core 3.0.0-beta.1 → 3.0.0-beta.4

package/test/util/path.test.ts

@@ -35,7 +35,7 @@ test('resolve ', t => {
       }
     }
   };
-  t.deepEqual(Resolve.schema(schema, '#/properties/foo'), {
+  t.deepEqual(Resolve.schema(schema, '#/properties/foo', schema), {
     type: 'integer'
   });
 });
@@ -46,12 +46,39 @@ test('toDataPath ', t => {
 test('toDataPath replace anyOf', t => {
   t.is(toDataPath('/anyOf/1/properties/foo/anyOf/1/properties/bar'), 'foo.bar');
 });
+test('toDataPath replace anyOf in combination with conditional schema compositions', t => {
+  t.is(toDataPath('/anyOf/1/then/properties/foo'), 'foo');
+});
+test('toDataPath replace multiple directly nested anyOf in combination with conditional schema compositions', t => {
+  t.is(toDataPath('/anyOf/1/then/anyOf/0/then/properties/foo'), 'foo');
+});
+test('toDataPath replace multiple nested properties with anyOf in combination with conditional schema compositions', t => {
+  t.is(toDataPath('/anyOf/1/properties/foo/anyOf/0/then/properties/bar'), 'foo.bar');
+});
 test('toDataPath replace allOf', t => {
   t.is(toDataPath('/allOf/1/properties/foo/allOf/1/properties/bar'), 'foo.bar');
 });
+test('toDataPath replace allOf in combination with conditional schema compositions', t => {
+  t.is(toDataPath('/allOf/1/then/properties/foo'), 'foo');
+});
+test('toDataPath replace multiple directly nested allOf in combination with conditional schema compositions', t => {
+  t.is(toDataPath('/allOf/1/then/allOf/0/then/properties/foo'), 'foo');
+});
+test('toDataPath replace multiple nested properties with allOf in combination with conditional schema compositions', t => {
+  t.is(toDataPath('/allOf/1/properties/foo/allOf/0/then/properties/bar'), 'foo.bar');
+});
 test('toDataPath replace oneOf', t => {
   t.is(toDataPath('/oneOf/1/properties/foo/oneOf/1/properties/bar'), 'foo.bar');
 });
+test('toDataPath replace oneOf in combination with conditional schema compositions', t => {
+  t.is(toDataPath('/oneOf/1/then/properties/foo'), 'foo');
+});
+test('toDataPath replace multiple directly nested oneOf in combination with conditional schema compositions', t => {
+  t.is(toDataPath('/oneOf/1/then/oneOf/0/then/properties/foo'), 'foo');
+});
+test('toDataPath replace multiple nested properties with oneOf in combination with conditional schema compositions', t => {
+  t.is(toDataPath('/oneOf/1/properties/foo/oneOf/0/then/properties/bar'), 'foo.bar');
+});
 test('toDataPath replace all combinators', t => {
   t.is(
     toDataPath(
@@ -87,6 +114,9 @@ test('toDataPath use of encoded paths relative without /', t => {
   const fooBar = encodeURIComponent('foo/bar');
   t.is(toDataPath(`properties/${fooBar}`), `${fooBar}`);
 });
+test('toDataPath use of encoded special character in pathname', t => {
+  t.is(toDataPath('properties/foo~0bar~1baz'), 'foo~bar/baz');
+});
 test('resolve instance', t => {
   const instance = { foo: 123 };
   const result = Resolve.data(instance, toDataPath('#/properties/foo'));
@@ -136,10 +166,10 @@ test('resolve $ref', t => {
       }
     }
   };
-  const result = Resolve.schema(schema, '#/properties/foos/items');
+  const result = Resolve.schema(schema, '#/properties/foos/items', schema);
   t.deepEqual(result, { type: 'string' });
 });
-test.failing('resolve $ref simple', t => {
+test('resolve $ref simple', t => {
   const schema: JsonSchema = {
     definitions: {
       foo: {
@@ -164,21 +194,21 @@ test.failing('resolve $ref simple', t => {
       }
     }
   };
-  const result = Resolve.schema(schema, '#/properties/foos/items');
+  const result = Resolve.schema(schema, '#/properties/foos/items', schema);
   t.deepEqual(result, {
     type: 'object',
     properties: {
       bar: {
         type: 'array',
         items: {
-          $ref: '#'
+          $ref: '#/definitions/foo'
         }
       }
     }
   });
   t.not((schema.definitions.foo.properties.bar.items as JsonSchema).$ref, '#');
 });
-test.failing('resolve $ref complicated', t => {
+test('resolve $ref complicated', t => {
   const schema: JsonSchema = {
     definitions: {
       foo: {
@@ -214,21 +244,8 @@ test.failing('resolve $ref complicated', t => {
       }
     }
   };
-  const result = Resolve.schema(schema, '#/properties/foos/items');
+  const result = Resolve.schema(schema, '#/properties/foos/items', schema);
   t.deepEqual(result, {
-    definitions: {
-      foo2: {
-        type: 'object',
-        properties: {
-          bar: {
-            type: 'array',
-            items: {
-              $ref: '#'
-            }
-          }
-        }
-      }
-    },
     type: 'object',
     properties: {
       bar: {

package/test/util/renderer.test.ts

@@ -1344,7 +1344,7 @@ test('mapStateToControlProps - i18n - translation via UI Schema i18n key', t =>
   };
   const state: JsonFormsState = createState(coreUISchema);
   state.jsonforms.i18n = defaultJsonFormsI18nState;
-  ownProps.uischema = {...ownProps.uischema, options: {i18n: 'my-key'}};
+  ownProps.uischema = {...ownProps.uischema, i18n: 'my-key'};
   state.jsonforms.i18n.translate = (key: string, defaultMessage: string | undefined) => {
     switch(key){
       case 'my-key.label': return 'my label';

package/test/util/resolvers.test.ts

@@ -27,6 +27,29 @@ import test from 'ava';
 
 test('resolveSchema - resolves schema with any ', t => {
   const schema = {
+    $defs: {
+      Base: {
+        type: 'object',
+        properties: {
+          width: {
+            type: 'integer'
+          }
+        }
+      },
+      Child: {
+        type: 'object',
+        allOf: [
+          { $ref: '#/$defs/Base' },
+          {
+            properties: {
+              geometry: {
+                type: 'string'
+              }
+            }
+          }
+        ]
+      }
+    },
     type: 'object',
     properties: {
       description: {
@@ -51,16 +74,84 @@ test('resolveSchema - resolves schema with any ', t => {
               type: 'boolean'
             }
           }
+        },
+        {
+          type: 'object',
+          properties: {
+            element: {
+              $ref: '#/$defs/Child'
+            }
+          }
         }]
       }
-    }
+    },
+    anyOf: [
+      {
+        if: {
+          properties: {
+            exist: {
+              const: true
+            }
+          }
+        },
+        then: {
+          properties: {
+            lastname: {
+              type: 'string'
+            }
+          }
+        },
+        else: {
+          properties: {
+            firstname: {
+              type: 'string'
+            },
+            address: {
+              type: 'object',
+              anyOf: [
+                {
+                  properties: {
+                    street: {
+                      type: 'string'
+                    }
+                  }
+                }
+              ]
+            }
+          }
+        }
+      }
+    ]
   };
   // test backward compatibility
-  t.deepEqual(resolveSchema(schema, '#/properties/description/oneOf/0/properties/name'), {type: 'string'});
-  t.deepEqual(resolveSchema(schema, '#/properties/description/oneOf/1/properties/index'), {type: 'number'});
+  t.deepEqual(resolveSchema(schema, '#/properties/description/oneOf/0/properties/name', schema), {type: 'string'});
+  t.deepEqual(resolveSchema(schema, '#/properties/description/oneOf/1/properties/index', schema), {type: 'number'});
+  t.deepEqual(resolveSchema(schema, '#/anyOf/0/then/properties/lastname', schema), {type: 'string'});
+  t.deepEqual(resolveSchema(schema, '#/anyOf/0/else/properties/firstname', schema), {type: 'string'});
+  t.deepEqual(resolveSchema(schema, '#/anyOf/0/else/properties/address/anyOf/0/properties/street', schema), {type: 'string'});
   // new simple approach
-  t.deepEqual(resolveSchema(schema, '#/properties/description/properties/name'), {type: 'string'});
-  t.deepEqual(resolveSchema(schema, '#/properties/description/properties/index'), {type: 'number'});
-  t.deepEqual(resolveSchema(schema, '#/properties/description/properties/exist'), {type: 'boolean'});
-  t.is(resolveSchema(schema, '#/properties/description/properties/notfound'), undefined);
-});
+  t.deepEqual(resolveSchema(schema, '#/properties/description/properties/name', schema), {type: 'string'});
+  t.deepEqual(resolveSchema(schema, '#/properties/description/properties/index', schema), {type: 'number'});
+  t.deepEqual(resolveSchema(schema, '#/properties/description/properties/exist', schema), {type: 'boolean'});
+  t.deepEqual(resolveSchema(schema, '#/properties/lastname', schema), {type: 'string'});
+  t.deepEqual(resolveSchema(schema, '#/properties/firstname', schema), {type: 'string'});
+  t.deepEqual(resolveSchema(schema, '#/properties/address/properties/street', schema), {type: 'string'});
+  t.is(resolveSchema(schema, '#/properties/description/properties/notfound', schema), undefined);
+  // refs
+  t.deepEqual(resolveSchema(schema, '#/properties/description/properties/element/properties/geometry', schema), {type: 'string'});
+  t.deepEqual(resolveSchema(schema, '#/properties/description/properties/element/properties/width', schema), {type: 'integer'});
+
+});
+
+test('resolveSchema - resolves schema with encoded characters', t => {
+  const schema = {
+    type: 'object',
+    properties: {
+      'foo / ~ bar': {
+        type: 'integer'
+      }
+    }
+  };
+  t.deepEqual(resolveSchema(schema, '#/properties/foo ~1 ~0 bar', schema), {type: 'integer'});
+  t.is(resolveSchema(schema, '#/properties/foo / bar', schema), undefined);
+});