@jsonforms/core 3.6.0 → 3.7.0-alpha.0

package/lib/jsonforms-core.esm.js

@@ -279,41 +279,98 @@ const findAllRefs = (schema, result = {}, resolveTuples = false) => {
 };
 const invalidSegment = (pathSegment) => pathSegment === '#' || pathSegment === undefined || pathSegment === '';
 const resolveSchema = (schema, schemaPath, rootSchema) => {
-    const segments = schemaPath?.split('/').map(decode);
-    return resolveSchemaWithSegments(schema, segments, rootSchema);
+    const result = doResolveSchema(schema, schemaPath, {
+        rootSchema,
+        resolutionMap: new Map(),
+    });
+    return result;
 };
-const resolveSchemaWithSegments = (schema, pathSegments, rootSchema) => {
-    if (typeof schema?.$ref === 'string') {
-        schema = resolveSchema(rootSchema, schema.$ref, rootSchema);
+const doResolveSchema = (schema, schemaPath, ctx) => {
+    let resolvedSchema = undefined;
+    if (schema && typeof schema.$ref === 'string') {
+        const baseSchema = resolvePath(ctx.rootSchema, schema.$ref, ctx);
+        if (baseSchema !== undefined) {
+            resolvedSchema = resolvePath(baseSchema, schemaPath, ctx);
+        }
+    }
+    if (resolvedSchema === undefined) {
+        resolvedSchema = resolvePath(schema, schemaPath, ctx);
+    }
+    return resolvedSchema;
+};
+const resolvePath = (schema, schemaPath, ctx) => {
+    let visitedPaths = ctx.resolutionMap.get(schema);
+    if (!visitedPaths) {
+        visitedPaths = new Set();
+        ctx.resolutionMap.set(schema, visitedPaths);
+    }
+    if (visitedPaths.has(schemaPath)) {
+        return undefined;
     }
+    visitedPaths.add(schemaPath);
+    const resolvedSchema = resolvePathSegmentsWithCombinatorFallback(schema, schemaPath?.split('/').map(decode), ctx);
+    visitedPaths.delete(schemaPath);
+    return resolvedSchema;
+};
+const resolvePathSegmentsWithCombinatorFallback = (schema, pathSegments, ctx) => {
     if (!pathSegments || pathSegments.length === 0) {
         return schema;
     }
     if (isEmpty(schema)) {
         return undefined;
     }
-    const [segment, ...remainingSegments] = pathSegments;
-    if (invalidSegment(segment)) {
-        return resolveSchemaWithSegments(schema, remainingSegments, rootSchema);
-    }
-    const singleSegmentResolveSchema = get(schema, segment);
-    const resolvedSchema = resolveSchemaWithSegments(singleSegmentResolveSchema, remainingSegments, rootSchema);
-    if (resolvedSchema) {
+    const resolvedSchema = resolvePathSegments(schema, pathSegments, ctx);
+    if (resolvedSchema !== undefined) {
         return resolvedSchema;
     }
-    if (segment === 'properties' || segment === 'items') {
-        let alternativeResolveResult = undefined;
-        const subSchemas = [].concat(schema.oneOf ?? [], schema.allOf ?? [], schema.anyOf ?? [], schema.then ?? [], schema.else ?? []);
-        for (const subSchema of subSchemas) {
-            alternativeResolveResult = resolveSchemaWithSegments(subSchema, [segment, ...remainingSegments], rootSchema);
-            if (alternativeResolveResult) {
-                break;
-            }
+    const subSchemas = [].concat(schema.oneOf ?? [], schema.allOf ?? [], schema.anyOf ?? [], schema.then ?? [], schema.else ?? []);
+    for (const subSchema of subSchemas) {
+        let resolvedSubSchema = subSchema;
+        if (subSchema && typeof subSchema.$ref === 'string') {
+            resolvedSubSchema = doResolveSchema(ctx.rootSchema, subSchema.$ref, ctx);
+        }
+        const alternativeResolveResult = resolvePathSegmentsWithCombinatorFallback(resolvedSubSchema, pathSegments, ctx);
+        if (alternativeResolveResult) {
+            return alternativeResolveResult;
         }
-        return alternativeResolveResult;
     }
     return undefined;
 };
+const resolvePathSegments = (schema, pathSegments, ctx) => {
+    if (!pathSegments || pathSegments.length === 0) {
+        return schema;
+    }
+    if (isEmpty(schema)) {
+        return undefined;
+    }
+    const singleStepResult = resolveSingleStep(schema, pathSegments);
+    if (singleStepResult.schema &&
+        typeof singleStepResult.schema.$ref === 'string') {
+        singleStepResult.schema = doResolveSchema(ctx.rootSchema, singleStepResult.schema.$ref, ctx);
+    }
+    return resolvePathSegmentsWithCombinatorFallback(singleStepResult.schema, singleStepResult.remainingPathSegments, ctx);
+};
+const resolveSingleStep = (schema, pathSegments) => {
+    if (!pathSegments || pathSegments.length === 0) {
+        return { schema, remainingPathSegments: [] };
+    }
+    if (isEmpty(schema)) {
+        return {
+            schema: undefined,
+            remainingPathSegments: pathSegments,
+        };
+    }
+    const [segment, ...remainingPathSegments] = pathSegments;
+    if (invalidSegment(segment)) {
+        return resolveSingleStep(schema, remainingPathSegments);
+    }
+    const singleSegmentResolveSchema = get(schema, segment);
+    return {
+        schema: singleSegmentResolveSchema,
+        remainingPathSegments,
+        resolvedSegment: segment,
+    };
+};
 
 const Draft4 = {
     id: 'http://json-schema.org/draft-04/schema#',