@stoplight/elements-core 7.14.0 → 7.15.1

package/index.mjs

@@ -119,23 +119,25 @@ const InlineRefResolverContext = React.createContext(undefined);
 InlineRefResolverContext.displayName = 'InlineRefResolverContext';
 const DocumentContext = React.createContext(undefined);
 DocumentContext.displayName = 'DocumentContext';
-const InlineRefResolverProvider = ({ children, document: maybeDocument, resolver, }) => {
+const InlineRefResolverProvider = ({ children, document: maybeDocument, resolver, maxRefDepth, }) => {
     const document = isPlainObject$1(maybeDocument) ? maybeDocument : undefined;
     const computedResolver = React.useMemo(() => resolver || (document !== undefined ? defaultResolver(document) : undefined), [document, resolver]);
-    return (React.createElement(InlineRefResolverContext.Provider, { value: computedResolver },
+    return (React.createElement(InlineRefResolverContext.Provider, { value: { resolver: computedResolver, maxRefDepth } },
         React.createElement(DocumentContext.Provider, { value: document }, children)));
 };
 const useInlineRefResolver = () => useContext(InlineRefResolverContext);
 const useDocument = () => useContext(DocumentContext);
 const useResolvedObject = (currentObject) => {
+    var _a;
     const document = useDocument();
-    const resolver = useInlineRefResolver();
+    const { resolver } = (_a = useInlineRefResolver()) !== null && _a !== void 0 ? _a : {};
     return React.useMemo(() => createResolvedObject(currentObject, { contextObject: document, resolver }), [currentObject, document, resolver]);
 };
 const useSchemaInlineRefResolver = () => {
+    var _a;
     const document = useDocument();
-    const resolver = useInlineRefResolver();
-    return React.useCallback((...args) => {
+    const { resolver, maxRefDepth } = (_a = useInlineRefResolver()) !== null && _a !== void 0 ? _a : {};
+    const referenceResolver = React.useCallback((...args) => {
         const resolved = resolver === null || resolver === void 0 ? void 0 : resolver(...args);
         if (!isPlainObject$1(resolved)) {
             return resolved;
@@ -151,6 +153,7 @@ const useSchemaInlineRefResolver = () => {
         delete converted.$schema;
         return converted;
     }, [document, resolver]);
+    return [referenceResolver, maxRefDepth];
 };
 
 const DEFAULT_CONTEXT = {};
@@ -2446,7 +2449,7 @@ const isBodyEmpty = (body) => {
 };
 const Body = ({ body, onChange }) => {
     var _a;
-    const refResolver = useSchemaInlineRefResolver();
+    const [refResolver, maxRefDepth] = useSchemaInlineRefResolver();
     const [chosenContent, setChosenContent] = React.useState(0);
     const { nodeHasChanged } = useOptionsCtx();
     React.useEffect(() => {
@@ -2463,7 +2466,7 @@ const Body = ({ body, onChange }) => {
         description && (React.createElement(Box, { pos: "relative" },
             React.createElement(MarkdownViewer, { markdown: description }),
             React.createElement(NodeAnnotation, { change: descriptionChanged }))),
-        isJSONSchema(schema) && (React.createElement(JsonSchemaViewer, { resolveRef: refResolver, schema: getOriginalObject(schema), viewMode: "write", renderRootTreeLines: true, nodeHasChanged: nodeHasChanged }))));
+        isJSONSchema(schema) && (React.createElement(JsonSchemaViewer, { resolveRef: refResolver, maxRefDepth: maxRefDepth, schema: getOriginalObject(schema), viewMode: "write", renderRootTreeLines: true, nodeHasChanged: nodeHasChanged }))));
 };
 Body.displayName = 'HttpOperation.Body';
 
@@ -2488,11 +2491,11 @@ const defaultStyle = {
 };
 const Parameters = ({ parameters, parameterType }) => {
     const { nodeHasChanged } = useOptionsCtx();
-    const refResolver = useSchemaInlineRefResolver();
+    const [refResolver, maxRefDepth] = useSchemaInlineRefResolver();
     const schema = React.useMemo(() => httpOperationParamsToSchema({ parameters, parameterType }), [parameters, parameterType]);
     if (!schema)
         return null;
-    return React.createElement(JsonSchemaViewer, { resolveRef: refResolver, schema: schema, disableCrumbs: true, nodeHasChanged: nodeHasChanged });
+    return (React.createElement(JsonSchemaViewer, { resolveRef: refResolver, maxRefDepth: maxRefDepth, schema: schema, disableCrumbs: true, nodeHasChanged: nodeHasChanged }));
 };
 Parameters.displayName = 'HttpOperation.Parameters';
 const httpOperationParamsToSchema = ({ parameters, parameterType }) => {
@@ -2626,7 +2629,7 @@ Responses.displayName = 'HttpOperation.Responses';
 const Response = ({ response, onMediaTypeChange }) => {
     const { contents = [], headers = [], description } = response;
     const [chosenContent, setChosenContent] = React.useState(0);
-    const refResolver = useSchemaInlineRefResolver();
+    const [refResolver, maxRefDepth] = useSchemaInlineRefResolver();
     const { nodeHasChanged } = useOptionsCtx();
     const responseContent = contents[chosenContent];
     const schema = responseContent === null || responseContent === void 0 ? void 0 : responseContent.schema;
@@ -2645,7 +2648,7 @@ const Response = ({ response, onMediaTypeChange }) => {
             React.createElement(SectionSubtitle, { title: "Body", id: "response-body" },
                 React.createElement(Flex, { flex: 1, justify: "end" },
                     React.createElement(Select, { "aria-label": "Response Body Content Type", value: String(chosenContent), onChange: value => setChosenContent(parseInt(String(value), 10)), options: contents.map((content, index) => ({ label: content.mediaType, value: index })), size: "sm" }))),
-            schema && (React.createElement(JsonSchemaViewer, { schema: getOriginalObject(schema), resolveRef: refResolver, viewMode: "read", parentCrumbs: ['responses', response.code], renderRootTreeLines: true, nodeHasChanged: nodeHasChanged }))))));
+            schema && (React.createElement(JsonSchemaViewer, { schema: getOriginalObject(schema), resolveRef: refResolver, maxRefDepth: maxRefDepth, viewMode: "read", parentCrumbs: ['responses', response.code], renderRootTreeLines: true, nodeHasChanged: nodeHasChanged }))))));
 };
 Response.displayName = 'HttpOperation.Response';
 const codeToIntentVal = (code) => {
@@ -2929,7 +2932,7 @@ const HttpService = withErrorBoundary(HttpServiceComponent, { recoverableProps:
 
 const ModelComponent = ({ data: unresolvedData, className, nodeTitle, layoutOptions, exportProps, }) => {
     var _a, _b;
-    const resolveRef = useSchemaInlineRefResolver();
+    const [resolveRef, maxRefDepth] = useSchemaInlineRefResolver();
     const data = useResolvedObject(unresolvedData);
     const { nodeHasChanged } = useOptionsCtx();
     const { ref: layoutRef, isCompact } = useIsCompact(layoutOptions);
@@ -2955,7 +2958,7 @@ const ModelComponent = ({ data: unresolvedData, className, nodeTitle, layoutOpti
             React.createElement(MarkdownViewer, { role: "textbox", markdown: data.description }),
             React.createElement(NodeAnnotation, { change: descriptionChanged }))),
         isCompact && modelExamples,
-        React.createElement(JsonSchemaViewer, { resolveRef: resolveRef, schema: getOriginalObject(data), nodeHasChanged: nodeHasChanged, skipTopLevelDescription: true })));
+        React.createElement(JsonSchemaViewer, { resolveRef: resolveRef, maxRefDepth: maxRefDepth, schema: getOriginalObject(data), nodeHasChanged: nodeHasChanged, skipTopLevelDescription: true })));
     return (React.createElement(TwoColumnLayout, { ref: layoutRef, className: cn('Model', className), header: header, left: description, right: !isCompact && modelExamples }));
 };
 const ModelExamples = React.memo(({ data, isCollapsible = false }) => {
@@ -2978,7 +2981,7 @@ const Model = withErrorBoundary(ModelComponent, { recoverableProps: ['data'] });
 
 const Docs = React.memo((_a) => {
     var _b;
-    var { nodeType, nodeData, useNodeForRefResolving = false, refResolver, nodeHasChanged } = _a, commonProps = __rest(_a, ["nodeType", "nodeData", "useNodeForRefResolving", "refResolver", "nodeHasChanged"]);
+    var { nodeType, nodeData, useNodeForRefResolving = false, refResolver, maxRefDepth, nodeHasChanged } = _a, commonProps = __rest(_a, ["nodeType", "nodeData", "useNodeForRefResolving", "refResolver", "maxRefDepth", "nodeHasChanged"]);
     const parsedNode = useParsedData(nodeType, nodeData);
     if (!parsedNode) {
         (_b = commonProps.nodeUnsupported) === null || _b === void 0 ? void 0 : _b.call(commonProps, 'dataEmpty');
@@ -2986,7 +2989,7 @@ const Docs = React.memo((_a) => {
     }
     let elem = React.createElement(ParsedDocs, Object.assign({ node: parsedNode }, commonProps));
     if (useNodeForRefResolving) {
-        elem = (React.createElement(InlineRefResolverProvider, { document: parsedNode.data, resolver: refResolver }, elem));
+        elem = (React.createElement(InlineRefResolverProvider, { document: parsedNode.data, resolver: refResolver, maxRefDepth: maxRefDepth }, elem));
     }
     return React.createElement(ElementsOptionsProvider, { nodeHasChanged: nodeHasChanged }, elem);
 });
@@ -3098,13 +3101,13 @@ function isPartialHttpRequest(maybeHttpRequest) {
         typeof maybeHttpRequest['url'] === 'string');
 }
 const SchemaAndDescription = ({ title: titleProp, schema }) => {
-    const resolveRef = useSchemaInlineRefResolver();
+    const [resolveRef, maxRefDepth] = useSchemaInlineRefResolver();
     const title = titleProp !== null && titleProp !== void 0 ? titleProp : schema.title;
     return (React__default.createElement(Box, { py: 2 },
         title && (React__default.createElement(Flex, { alignItems: "center", p: 2 },
             React__default.createElement(Icon, { icon: NodeTypeIconDefs[NodeType.Model], color: NodeTypeColors[NodeType.Model] }),
             React__default.createElement(Box, { color: "muted", px: 2 }, title))),
-        React__default.createElement(JsonSchemaViewer, { resolveRef: resolveRef, schema: getOriginalObject(schema) })));
+        React__default.createElement(JsonSchemaViewer, { resolveRef: resolveRef, maxRefDepth: maxRefDepth, schema: getOriginalObject(schema) })));
 };
 const CodeComponent = props => {
     const { title, jsonSchema, http, resolved, children } = props;
@@ -3115,7 +3118,7 @@ const CodeComponent = props => {
         if (!isJSONSchema(parsedValue)) {
             return null;
         }
-        return (React__default.createElement(InlineRefResolverProvider, { document: parsedValue, resolver: resolver },
+        return (React__default.createElement(InlineRefResolverProvider, { document: parsedValue, resolver: resolver === null || resolver === void 0 ? void 0 : resolver.resolver, maxRefDepth: resolver === null || resolver === void 0 ? void 0 : resolver.maxRefDepth },
             React__default.createElement(SchemaAndDescription, { title: title, schema: parsedValue })));
     }
     if (http) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stoplight/elements-core",
-  "version": "7.14.0",
+  "version": "7.15.1",
   "main": "./index.js",
   "sideEffects": [
     "web-components.min.js",
@@ -28,12 +28,12 @@
     "@stoplight/json": "^3.18.1",
     "@stoplight/json-schema-ref-parser": "^9.0.5",
     "@stoplight/json-schema-sampler": "0.2.3",
-    "@stoplight/json-schema-tree": "^2.2.5",
-    "@stoplight/json-schema-viewer": "^4.13.0",
+    "@stoplight/json-schema-tree": "^2.3.0",
+    "@stoplight/json-schema-viewer": "^4.14.0",
     "@stoplight/markdown-viewer": "^5.6.0",
-    "@stoplight/mosaic": "^1.44.4",
-    "@stoplight/mosaic-code-editor": "^1.44.4",
-    "@stoplight/mosaic-code-viewer": "^1.44.4",
+    "@stoplight/mosaic": "^1.46.1",
+    "@stoplight/mosaic-code-editor": "^1.46.1",
+    "@stoplight/mosaic-code-viewer": "^1.46.1",
     "@stoplight/path": "^1.3.2",
     "@stoplight/react-error-boundary": "^2.0.0",
     "@stoplight/types": "^14.0.0",