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

package/src/testers/testers.ts

@@ -47,15 +47,17 @@ import { deriveTypes, hasType, resolveSchema } from '../util';
 export const NOT_APPLICABLE = -1;
 /**
  * A tester is a function that receives an UI schema and a JSON schema and returns a boolean.
+ * The rootSchema is handed over as context. Can be used to resolve references.
  */
-export type Tester = (uischema: UISchemaElement, schema: JsonSchema) => boolean;
+export type Tester = (uischema: UISchemaElement, schema: JsonSchema, rootSchema: JsonSchema) => boolean;
 
 /**
  * A ranked tester associates a tester with a number.
  */
 export type RankedTester = (
   uischema: UISchemaElement,
-  schema: JsonSchema
+  schema: JsonSchema,
+  rootSchema: JsonSchema
 ) => number;
 
 export const isControl = (uischema: any): uischema is ControlElement =>
@@ -72,8 +74,8 @@ export const isControl = (uischema: any): uischema is ControlElement =>
  *        applied to the resolved sub-schema
  */
 export const schemaMatches = (
-  predicate: (schema: JsonSchema) => boolean
-): Tester => (uischema: UISchemaElement, schema: JsonSchema): boolean => {
+  predicate: (schema: JsonSchema, rootSchema: JsonSchema) => boolean
+): Tester => (uischema: UISchemaElement, schema: JsonSchema, rootSchema: JsonSchema): boolean => {
   if (isEmpty(uischema) || !isControl(uischema)) {
     return false;
   }
@@ -86,26 +88,26 @@ export const schemaMatches = (
   }
   let currentDataSchema = schema;
   if (hasType(schema, 'object')) {
-    currentDataSchema = resolveSchema(schema, schemaPath);
+    currentDataSchema = resolveSchema(schema, schemaPath, rootSchema);
   }
   if (currentDataSchema === undefined) {
     return false;
   }
 
-  return predicate(currentDataSchema);
+  return predicate(currentDataSchema, rootSchema);
 };
 
 export const schemaSubPathMatches = (
   subPath: string,
-  predicate: (schema: JsonSchema) => boolean
-): Tester => (uischema: UISchemaElement, schema: JsonSchema): boolean => {
+  predicate: (schema: JsonSchema, rootSchema: JsonSchema) => boolean
+): Tester => (uischema: UISchemaElement, schema: JsonSchema, rootSchema: JsonSchema): boolean => {
   if (isEmpty(uischema) || !isControl(uischema)) {
     return false;
   }
   const schemaPath = uischema.scope;
   let currentDataSchema: JsonSchema = schema;
   if (hasType(schema, 'object')) {
-    currentDataSchema = resolveSchema(schema, schemaPath);
+    currentDataSchema = resolveSchema(schema, schemaPath, rootSchema);
   }
   currentDataSchema = get(currentDataSchema, subPath);
 
@@ -113,7 +115,7 @@ export const schemaSubPathMatches = (
     return false;
   }
 
-  return predicate(currentDataSchema);
+  return predicate(currentDataSchema, rootSchema);
 };
 
 /**
@@ -142,7 +144,7 @@ export const formatIs = (expectedFormat: string): Tester =>
     schema =>
       !isEmpty(schema) &&
       schema.format === expectedFormat &&
-      schema.type === 'string'
+      hasType(schema, 'string')
   );
 
 /**
@@ -215,8 +217,9 @@ export const scopeEndIs = (expected: string): Tester => (
  */
 export const and = (...testers: Tester[]): Tester => (
   uischema: UISchemaElement,
-  schema: JsonSchema
-) => testers.reduce((acc, tester) => acc && tester(uischema, schema), true);
+  schema: JsonSchema,
+  rootSchema: JsonSchema
+) => testers.reduce((acc, tester) => acc && tester(uischema, schema, rootSchema), true);
 
 /**
  * A tester that allow composing other testers by || them.
@@ -225,8 +228,9 @@ export const and = (...testers: Tester[]): Tester => (
  */
 export const or = (...testers: Tester[]): Tester => (
   uischema: UISchemaElement,
-  schema: JsonSchema
-) => testers.reduce((acc, tester) => acc || tester(uischema, schema), false);
+  schema: JsonSchema,
+  rootSchema: JsonSchema
+) => testers.reduce((acc, tester) => acc || tester(uischema, schema, rootSchema), false);
 /**
  * Create a ranked tester that will associate a number with a given tester, if the
  * latter returns true.
@@ -236,9 +240,10 @@ export const or = (...testers: Tester[]): Tester => (
  */
 export const rankWith = (rank: number, tester: Tester) => (
   uischema: UISchemaElement,
-  schema: JsonSchema
+  schema: JsonSchema,
+  rootSchema: JsonSchema
 ): number => {
-  if (tester(uischema, schema)) {
+  if (tester(uischema, schema, rootSchema)) {
     return rank;
   }
 
@@ -247,9 +252,10 @@ export const rankWith = (rank: number, tester: Tester) => (
 
 export const withIncreasedRank = (by: number, rankedTester: RankedTester) => (
   uischema: UISchemaElement,
-  schema: JsonSchema
+  schema: JsonSchema,
+  rootSchema: JsonSchema
 ): number => {
-  const rank = rankedTester(uischema, schema);
+  const rank = rankedTester(uischema, schema, rootSchema);
   if (rank === NOT_APPLICABLE) {
     return NOT_APPLICABLE;
   }
@@ -380,9 +386,12 @@ export const isDateTimeControl = and(
  */
 export const isObjectArray = and(
   schemaMatches(
-    schema => hasType(schema, 'array') && !Array.isArray(schema.items) // we don't care about tuples
+    (schema, rootSchema) => hasType(schema, 'array') && !Array.isArray(resolveSchema(schema, 'items', rootSchema)) // we don't care about tuples
   ),
-  schemaSubPathMatches('items', schema => hasType(schema, 'object'))
+  schemaSubPathMatches('items', (schema, rootSchema) => {
+    const resolvedSchema = schema.$ref ? resolveSchema(rootSchema, schema.$ref, rootSchema) : schema;
+    return hasType(resolvedSchema, 'object')
+  })
 );
 
 /**
@@ -394,22 +403,31 @@ export const isObjectArrayControl = and(uiTypeIs('Control'), isObjectArray);
 
 const traverse = (
   any: JsonSchema | JsonSchema[],
-  pred: (obj: JsonSchema) => boolean
+  pred: (obj: JsonSchema) => boolean,
+  rootSchema: JsonSchema
 ): boolean => {
   if (isArray(any)) {
-    return reduce(any, (acc, el) => acc || traverse(el, pred), false);
+    return reduce(any, (acc, el) => acc || traverse(el, pred, rootSchema), false);
   }
 
   if (pred(any)) {
     return true;
   }
+
+  if (any.$ref) {
+    const toTraverse = resolveSchema(rootSchema, any.$ref, rootSchema);
+    if (toTraverse && !toTraverse.$ref) {
+      return traverse(toTraverse, pred, rootSchema);
+    }
+  }
+
   if (any.items) {
-    return traverse(any.items, pred);
+    return traverse(any.items, pred, rootSchema);
   }
   if (any.properties) {
     return reduce(
       toPairs(any.properties),
-      (acc, [_key, val]) => acc || traverse(val, pred),
+      (acc, [_key, val]) => acc || traverse(val, pred, rootSchema),
       false
     );
   }
@@ -419,13 +437,14 @@ const traverse = (
 
 export const isObjectArrayWithNesting = (
   uischema: UISchemaElement,
-  schema: JsonSchema
+  schema: JsonSchema,
+  rootSchema: JsonSchema
 ): boolean => {
-  if (!uiTypeIs('Control')(uischema, schema)) {
+  if (!uiTypeIs('Control')(uischema, schema, rootSchema)) {
     return false;
   }
   const schemaPath = (uischema as ControlElement).scope;
-  const resolvedSchema = resolveSchema(schema, schemaPath);
+  const resolvedSchema = resolveSchema(schema, schemaPath, rootSchema ?? schema);
   const wantedNestingByType: { [key: string]: number } = {
     object: 2,
     array: 1
@@ -437,6 +456,9 @@ export const isObjectArrayWithNesting = (
         if (val === schema) {
           return false;
         }
+        if (val.$ref !== undefined) {
+          return false;
+        }
         // we don't support multiple types
         if (typeof val.type !== 'string') {
           return true;
@@ -447,7 +469,7 @@ export const isObjectArrayWithNesting = (
         }
         wantedNestingByType[val.type] = typeCount - 1;
         return wantedNestingByType[val.type] === 0;
-      })
+      }, rootSchema)
     ) {
       return true;
     }
@@ -479,10 +501,13 @@ export const isArrayObjectControl = isObjectArrayControl;
 export const isPrimitiveArrayControl = and(
   uiTypeIs('Control'),
   schemaMatches(
-    schema => deriveTypes(schema).length !== 0 && !Array.isArray(schema.items) // we don't care about tuples
+    (schema, rootSchema) =>
+      deriveTypes(schema).length !== 0 &&
+      !Array.isArray(resolveSchema(schema, 'items', rootSchema)) // we don't care about tuples
   ),
-  schemaSubPathMatches('items', schema => {
-    const types = deriveTypes(schema);
+  schemaSubPathMatches('items', (schema, rootSchema) => {
+    const resolvedSchema = schema.$ref ? resolveSchema(rootSchema, schema.$ref, rootSchema) : schema;
+    const types = deriveTypes(resolvedSchema);
     return (
       types.length === 1 &&
       includes(['integer', 'number', 'boolean', 'string'], types[0])
@@ -543,5 +568,7 @@ export const categorizationHasCategory = (uischema: UISchemaElement) =>
 
 export const not = (tester: Tester): Tester => (
   uischema: UISchemaElement,
-  schema: JsonSchema
-) => !tester(uischema, schema);
+  schema: JsonSchema,
+  rootSchema: JsonSchema
+
+) => !tester(uischema, schema, rootSchema);

package/src/util/combinators.ts

@@ -24,8 +24,8 @@
 */
 
 import { ControlElement, JsonSchema, UISchemaElement } from '../models';
-import { resolveSchema } from './resolvers';
 import { findUISchema, JsonFormsUISchemaRegistryEntry } from '../reducers';
+import { Resolve } from './util';
 
 export interface CombinatorSubSchemaRenderInfo {
   schema: JsonSchema;
@@ -47,24 +47,6 @@ const createLabel = (
   }
 };
 
-export const resolveSubSchemas = (
-  schema: JsonSchema,
-  rootSchema: JsonSchema,
-  keyword: CombinatorKeyword
-) => {
-  // resolve any $refs, otherwise the generated UI schema can't match the schema???
-  const schemas = schema[keyword] as any[];
-  if (schemas.findIndex(e => e.$ref !== undefined) !== -1) {
-    return {
-      ...schema,
-      [keyword]: (schema[keyword] as any[]).map(e =>
-        e.$ref ? resolveSchema(rootSchema, e.$ref) : e
-      )
-    };
-  }
-  return schema;
-};
-
 export const createCombinatorRenderInfos = (
   combinatorSubSchemas: JsonSchema[],
   rootSchema: JsonSchema,
@@ -73,16 +55,19 @@ export const createCombinatorRenderInfos = (
   path: string,
   uischemas: JsonFormsUISchemaRegistryEntry[]
 ): CombinatorSubSchemaRenderInfo[] =>
-  combinatorSubSchemas.map((subSchema, subSchemaIndex) => ({
-    schema: subSchema,
-    uischema: findUISchema(
-      uischemas,
-      subSchema,
-      control.scope,
-      path,
-      undefined,
-      control,
-      rootSchema
-    ),
-    label: createLabel(subSchema, subSchemaIndex, keyword)
-  }));
+  combinatorSubSchemas.map((subSchema, subSchemaIndex) => {
+    const schema = subSchema.$ref ? Resolve.schema(rootSchema, subSchema.$ref, rootSchema) : subSchema;
+    return {
+      schema,
+      uischema: findUISchema(
+        uischemas,
+        schema,
+        control.scope,
+        path,
+        undefined,
+        control,
+        rootSchema
+      ),
+      label: createLabel(subSchema, subSchemaIndex, keyword)
+    }
+  });

package/src/util/label.ts

@@ -26,6 +26,7 @@
 import startCase from 'lodash/startCase';
 
 import { ControlElement, JsonSchema, LabelDescription } from '../models';
+import { decode } from './path';
 
 const deriveLabel = (
   controlElement: ControlElement,
@@ -36,8 +37,7 @@ const deriveLabel = (
   }
   if (typeof controlElement.scope === 'string') {
     const ref = controlElement.scope;
-    const label = ref.substr(ref.lastIndexOf('/') + 1);
-
+    const label = decode(ref.substr(ref.lastIndexOf('/') + 1));
     return startCase(label);
   }
 

package/src/util/path.ts

@@ -57,14 +57,15 @@ export { compose as composePaths };
  */
 export const toDataPathSegments = (schemaPath: string): string[] => {
   const s = schemaPath
-    .replace(/anyOf\/[\d]\//g, '')
-    .replace(/allOf\/[\d]\//g, '')
-    .replace(/oneOf\/[\d]\//g, '');
+    .replace(/(anyOf|allOf|oneOf)\/[\d]\//g, '')
+    .replace(/(then|else)\//g, '');
   const segments = s.split('/');
 
-  const startFromRoot = segments[0] === '#' || segments[0] === '';
+  const decodedSegments = segments.map(decode);
+
+  const startFromRoot = decodedSegments[0] === '#' || decodedSegments[0] === '';
   const startIndex = startFromRoot ? 2 : 1;
-  return range(startIndex, segments.length, 2).map(idx => segments[idx]);
+  return range(startIndex, decodedSegments.length, 2).map(idx => decodedSegments[idx]);
 };
 
 /**
@@ -77,7 +78,7 @@ export const toDataPathSegments = (schemaPath: string): string[] => {
  */
 export const toDataPath = (schemaPath: string): string => {
   return toDataPathSegments(schemaPath).join('.');
-};
+    };
 
 export const composeWithUi = (scopableUi: Scopable, path: string): string => {
   const segments = toDataPathSegments(scopableUi.scope);
@@ -88,3 +89,14 @@ export const composeWithUi = (scopableUi: Scopable, path: string): string => {
 
   return isEmpty(segments) ? path : compose(path, segments.join('.'));
 };
+
+/**
+ * Encodes the given segment to be used as part of a JSON Pointer
+ * 
+ * JSON Pointer has special meaning for "/" and "~", therefore these must be encoded
+ */
+export const encode = (segment: string) => segment?.replace(/~/g, '~0').replace(/\//g, '~1');
+/**
+ * Decodes a given JSON Pointer segment to its "normal" representation
+ */
+export const decode = (pointerSegment: string) => pointerSegment?.replace(/~1/g, '/').replace(/~0/, '~');

package/src/util/renderer.ts

@@ -26,7 +26,8 @@
 import get from 'lodash/get';
 import { ControlElement, JsonSchema, UISchemaElement } from '../models';
 import find from 'lodash/find';
-import type {
+import {
+  getUISchemas,
   JsonFormsCellRendererRegistryEntry,
   JsonFormsRendererRegistryEntry,
 } from '../reducers';
@@ -48,7 +49,7 @@ import {
 import { RankedTester } from '../testers';
 import { hasShowRule, isInherentlyEnabled, isVisible } from './runtime';
 import { createLabelDescriptionFrom } from './label';
-import { CombinatorKeyword, resolveSubSchemas } from './combinators';
+import { CombinatorKeyword } from './combinators';
 import { moveDown, moveUp } from './array';
 import { AnyAction, Dispatch } from './type';
 import { Resolve } from './util';
@@ -65,6 +66,7 @@ const isRequired = (
 ): boolean => {
   const pathSegments = schemaPath.split('/');
   const lastSegment = pathSegments[pathSegments.length - 1];
+  // Skip "properties", "items" etc. to resolve the parent
   const nextHigherSchemaSegments = pathSegments.slice(
     0,
     pathSegments.length - 2
@@ -463,8 +465,8 @@ export const mapStateToControlProps = (
   const schema = resolvedSchema ?? rootSchema;
   const t = getTranslator()(state);
   const te = getErrorTranslator()(state);
-  const i18nLabel = t(getI18nKey(schema, uischema, path, 'label'), label);
-  const i18nDescription = t(getI18nKey(schema, uischema, path, 'description'), description);
+  const i18nLabel = t(getI18nKey(schema, uischema, path, 'label'), label, {schema, uischema, path, errors} );
+  const i18nDescription = t(getI18nKey(schema, uischema, path, 'description'), description, {schema, uischema, path, errors});
   const i18nErrorMessage = getCombinedErrorMessage(errors, te, t, schema, uischema, path);
 
   return {
@@ -865,7 +867,8 @@ export const mapStateToLayoutProps = (
     data,
     uischema: ownProps.uischema,
     schema: ownProps.schema,
-    direction: ownProps.direction ?? getDirection(uischema)
+    direction: ownProps.direction ?? getDirection(uischema),
+    config
   };
 };
 
@@ -891,7 +894,10 @@ export const mapStateToJsonFormsRendererProps = (
         state.jsonforms.uischemas,
         ownProps.schema,
         undefined,
-        ownProps.path
+        ownProps.path,
+        undefined,
+        undefined,
+        state.jsonforms.core.schema
       );
     } else {
       uischema = getUiSchema(state);
@@ -913,7 +919,7 @@ export const controlDefaultProps = {
   errors: [] as string[]
 };
 
-export interface StatePropsOfCombinator extends OwnPropsOfControl {
+export interface StatePropsOfCombinator extends StatePropsOfControl {
   rootSchema: JsonSchema;
   path: string;
   id: string;
@@ -927,25 +933,12 @@ export const mapStateToCombinatorRendererProps = (
   ownProps: OwnPropsOfControl,
   keyword: CombinatorKeyword
 ): StatePropsOfCombinator => {
-  const { uischema } = ownProps;
-  const path = composeWithUi(uischema, ownProps.path);
-  const rootSchema = getSchema(state);
-  const resolvedSchema = Resolve.schema(
-    ownProps.schema || rootSchema,
-    uischema.scope,
-    rootSchema
+  const { data, schema, ...props } = mapStateToControlProps(
+    state,
+    ownProps
   );
-  const visible: boolean =
-    ownProps.visible === undefined || hasShowRule(uischema)
-      ? isVisible(uischema, getData(state), ownProps.path, getAjv(state))
-      : ownProps.visible;
-  const id = ownProps.id;
-
-  const data = Resolve.data(getData(state), path);
 
   const ajv = state.jsonforms.core.ajv;
-  const schema = resolvedSchema || rootSchema;
-  const _schema = resolveSubSchemas(schema, rootSchema, keyword);
   const structuralKeywords = [
     'required',
     'additionalProperties',
@@ -964,9 +957,9 @@ export const mapStateToCombinatorRendererProps = (
   // TODO instead of compiling the combinator subschemas we can compile the original schema
   // without the combinator alternatives and then revalidate and check the errors for the
   // element
-  for (let i = 0; i < _schema[keyword].length; i++) {
+  for (let i = 0; i < schema[keyword]?.length; i++) {
     try {
-      const valFn = ajv.compile(_schema[keyword][i]);
+      const valFn = ajv.compile(schema[keyword][i]);
       valFn(data);
       if (dataIsValid(valFn.errors)) {
         indexOfFittingSchema = i;
@@ -979,14 +972,10 @@ export const mapStateToCombinatorRendererProps = (
 
   return {
     data,
-    path,
     schema,
-    rootSchema,
-    visible,
-    id,
+    ...props,
     indexOfFittingSchema,
-    uischemas: state.jsonforms.uischemas,
-    uischema
+    uischemas: getUISchemas(state)
   };
 };
 
@@ -1044,7 +1033,6 @@ export const mapStateToArrayLayoutProps = (
 
   const resolvedSchema = Resolve.schema(schema, 'items', props.rootSchema);
 
-  // TODO Does not consider a specialized '.custom' error message overriding all other error messages
   // TODO Does not consider 'i18n' keys which are specified in the ui schemas of the sub errors
   const childErrors = getCombinedErrorMessage(
     getSubErrorsAt(path, resolvedSchema)(state),

package/src/util/resolvers.ts

@@ -25,7 +25,8 @@
 
 import isEmpty from 'lodash/isEmpty';
 import get from 'lodash/get';
-import { JsonSchema } from '../models';
+import { JsonSchema, JsonSchema7 } from '../models';
+import { decode } from './path';
 
 /**
  * Map for storing refs and the respective schemas they are pointing to.
@@ -110,80 +111,68 @@ const invalidSegment = (pathSegment: string) =>
 export const resolveSchema = (
   schema: JsonSchema,
   schemaPath: string,
-  rootSchema?: JsonSchema
+  rootSchema: JsonSchema
+): JsonSchema => {
+  const segments = schemaPath?.split('/').map(decode);
+  return resolveSchemaWithSegments(schema, segments, rootSchema);
+};
+
+const resolveSchemaWithSegments = (
+  schema: JsonSchema,
+  pathSegments: string[],
+  rootSchema: JsonSchema
 ): JsonSchema => {
   if (isEmpty(schema)) {
     return undefined;
   }
-  const validPathSegments = schemaPath.split('/');
-  let resultSchema = schema;
-  for (let i = 0; i < validPathSegments.length; i++) {
-    let pathSegment = validPathSegments[i];
-    resultSchema =
-      resultSchema === undefined || resultSchema.$ref === undefined
-        ? resultSchema
-        : resolveSchema(schema, resultSchema.$ref);
-    if (invalidSegment(pathSegment)) {
-      // skip invalid segments
-      continue;
-    }
-    let curSchema = get(resultSchema, pathSegment);
-    if (!curSchema) {
-      // resolving was not successful, check whether the scope omitted an oneOf, allOf or anyOf and resolve anyway
-      const schemas = [].concat(
-        resultSchema?.oneOf ?? [],
-        resultSchema?.allOf ?? [],
-        resultSchema?.anyOf ?? []
-      );
-      for (let item of schemas) {
-        curSchema = resolveSchema(item, validPathSegments.slice(i).join('/'));
-        if (curSchema) {
-          break;
-        }
-      }
-      if (curSchema) {
-        // already resolved rest of the path
-        resultSchema = curSchema;
-        break;
-      }
-    }
-    resultSchema = curSchema;
+
+  if (schema.$ref) {
+    schema = resolveSchema(rootSchema, schema.$ref, rootSchema);
   }
-  // TODO: because schema is already scoped we might end up with refs pointing
-  // outside of the current schema. It would be better if we'd always could deal
-  // with absolute paths here, so that we don't need to keep two different
-  // schemas around
-  if (resultSchema !== undefined && resultSchema.$ref !== undefined) {
-    try {
-      return retrieveResolvableSchema(schema, resultSchema.$ref);
-    } catch (e) {
-      return retrieveResolvableSchema(rootSchema, resultSchema.$ref);
-    }
+
+  if (!pathSegments || pathSegments.length === 0) {
+    return schema;
   }
 
-  return resultSchema;
-};
+  const [segment, ...remainingSegments] = pathSegments;
 
-/**
- * Normalizes the schema and resolves the given ref.
- *
- * @param {JsonSchema} full the JSON schema to resolved the reference against
- * @param {string} reference the reference to be resolved
- * @returns {JsonSchema} the resolved sub-schema
- */
-// disable rule because resolve is mutually recursive
-// tslint:disable:only-arrow-functions
-function retrieveResolvableSchema(
-  full: JsonSchema,
-  reference: string
-): JsonSchema {
-  // tslint:enable:only-arrow-functions
-  const child = resolveSchema(full, reference);
-  const allRefs = findAllRefs(child);
-  const innerSelfReference = allRefs[reference];
-  if (innerSelfReference !== undefined) {
-    innerSelfReference.$ref = '#';
+  if (invalidSegment(segment)) {
+    return resolveSchemaWithSegments(schema, remainingSegments, rootSchema);
   }
 
-  return child;
-}
+  const singleSegmentResolveSchema = get(schema, segment);
+
+  const resolvedSchema = resolveSchemaWithSegments(singleSegmentResolveSchema, remainingSegments, rootSchema);
+  if (resolvedSchema) {
+    return resolvedSchema;
+  }
+
+  if (segment === 'properties' || segment === 'items') {
+    // Let's try to resolve the path, assuming oneOf/allOf/anyOf/then/else was omitted.
+    // We only do this when traversing an object or array as we want to avoid
+    // following a property which is named oneOf, allOf, anyOf, then or else.
+    let alternativeResolveResult = undefined;
+
+    const subSchemas = [].concat(
+      schema.oneOf ?? [],
+      schema.allOf ?? [],
+      schema.anyOf ?? [],
+      (schema as JsonSchema7).then ?? [],
+      (schema as JsonSchema7).else ?? []
+    );
+
+    for (const subSchema of subSchemas) {
+      alternativeResolveResult = resolveSchemaWithSegments(
+        subSchema,
+        [segment, ...remainingSegments],
+        rootSchema
+      );
+      if (alternativeResolveResult) {
+        break;
+      }
+    }
+    return alternativeResolveResult;
+  }
+
+  return undefined;
+}

package/src/util/util.ts

@@ -99,7 +99,7 @@ export const Resolve: {
  schema(
    schema: JsonSchema,
    schemaPath: string,
-   rootSchema?: JsonSchema
+   rootSchema: JsonSchema
  ): JsonSchema;
  data(data: any, path: string): any;
 } = {