feat(nodes): RegularNode#children should be undefined initially

Author: P0lip

src/__tests__/__snapshots__/tree.spec.ts.snap

@@ -250,7 +250,7 @@ describe('SchemaTree', () => {
                 │                                         └─ children
                 │                                            └─ 0
                 │                                               └─ #/properties/foo/items/properties/user/items/properties/user/items
-                │                                                  └─ mirrors: #/properties/foo/items
+                │                                                  └─ mirrors: #/properties/foo/items/properties/user/items
                 ├─ 1
                 │  └─ #/properties/bar
                 │     ├─ types

src/__tests__/tree.spec.ts

@@ -7,6 +7,7 @@ import type { MirroredSchemaNode, ReferenceNode, RegularNode, SchemaNode } from
 import type { SchemaTreeOptions } from '../../tree';
 import { SchemaTree } from '../../tree';
 import type { SchemaFragment } from '../../types';
+import { isNonNullable } from '../../utils';
 
 export function printTree(schema: SchemaFragment, opts?: Partial<SchemaTreeOptions>) {
   const tree = new SchemaTree(schema, opts);
@@ -28,7 +29,7 @@ function printRegularNode(this: WeakSet<SchemaFragment>, node: RegularNode): Dic
     ...(node.primaryType !== null ? { primaryType: node.primaryType } : null),
     ...(node.combiners !== null ? { combiners: node.combiners } : null),
     ...(node.enum !== null ? { enum: node.enum } : null),
-    ...(node.children !== null ? { children: node.children.map(prepareTree, this) } : null),
+    ...(isNonNullable(node.children) ? { children: node.children.map(prepareTree, this) } : null),
   };
 }
 

src/__tests__/utils/printTree.ts

@@ -26,7 +26,7 @@ export class RegularNode extends BaseNode {
   public readonly title: string | null;
   public readonly deprecated: boolean;
 
-  public children: (RegularNode | ReferenceNode | MirroredSchemaNode)[] | null;
+  public children: (RegularNode | ReferenceNode | MirroredSchemaNode)[] | null | undefined;
 
   public readonly meta: Readonly<Partial<Dictionary<unknown, SchemaMeta>>>;
   public readonly annotations: Readonly<Partial<Dictionary<unknown, SchemaAnnotations>>>;
@@ -49,7 +49,7 @@ export class RegularNode extends BaseNode {
     this.annotations = getAnnotations(fragment);
     this.validations = getValidations(fragment, this.types);
 
-    this.children = null;
+    this.children = void 0;
   }
 
   public get simple() {

src/nodes/RegularNode.ts

@@ -1,7 +1,9 @@
 import type { Dictionary } from '@stoplight/types';
 
-import { isMirroredNode, isRegularNode } from '../../guards';
+import { isRegularNode } from '../../guards';
+import { isNonNullable } from '../../utils';
 import { BaseNode } from '../BaseNode';
+import type { ReferenceNode } from '../ReferenceNode';
 import type { RegularNode } from '../RegularNode';
 import type { SchemaAnnotations, SchemaCombinerName, SchemaMeta, SchemaNodeKind } from '../types';
 import { MirroredReferenceNode } from './MirroredReferenceNode';
@@ -24,9 +26,13 @@ export class MirroredRegularNode extends BaseNode implements RegularNode {
   public readonly simple!: boolean;
   public readonly unknown!: boolean;
 
+  private readonly cache: WeakMap<RegularNode | ReferenceNode, MirroredRegularNode | MirroredReferenceNode>;
+
   constructor(public readonly mirroredNode: RegularNode) {
     super(mirroredNode.fragment);
 
+    this.cache = new WeakMap();
+
     this._this = new Proxy(this, {
       get(target, key) {
         if (key in target) {
@@ -49,38 +55,40 @@ export class MirroredRegularNode extends BaseNode implements RegularNode {
   }
 
   private readonly _this: MirroredRegularNode;
-  private _children?: (MirroredRegularNode | MirroredReferenceNode)[] | null;
 
-  public get children(): (MirroredRegularNode | MirroredReferenceNode)[] | null {
-    if (this._children !== void 0) {
-      return this._children;
-    }
+  private _children?: (MirroredRegularNode | MirroredReferenceNode)[];
+
+  public get children(): (MirroredRegularNode | MirroredReferenceNode)[] | null | undefined {
+    const referencedChildren = this.mirroredNode.children;
 
-    if (!('children' in this.mirroredNode)) {
-      this._children = null;
-      return null;
+    if (!isNonNullable(referencedChildren)) {
+      return referencedChildren;
     }
 
-    const referencedChildren = this.mirroredNode.children;
-    if (referencedChildren === null) {
-      this._children = null;
-      return null;
+    if (this._children === void 0) {
+      this._children = [];
+    } else {
+      this._children.length = 0;
     }
 
-    const children: (MirroredRegularNode | MirroredReferenceNode)[] = [];
+    const children: (MirroredRegularNode | MirroredReferenceNode)[] = this._children;
     for (const child of referencedChildren) {
       // this is to avoid pointing at nested mirroring
-      const actualChild = isMirroredNode(child) ? child.mirroredNode : child;
-      const mirroredChild = isRegularNode(actualChild)
-        ? new MirroredRegularNode(actualChild)
-        : new MirroredReferenceNode(actualChild);
+      const cached = this.cache.get(child);
+
+      if (cached !== void 0) {
+        children.push(cached);
+        continue;
+      }
+
+      const mirroredChild = isRegularNode(child) ? new MirroredRegularNode(child) : new MirroredReferenceNode(child);
 
       mirroredChild.parent = this._this;
-      mirroredChild.subpath = actualChild.subpath;
+      mirroredChild.subpath = child.subpath;
+      this.cache.set(child, mirroredChild);
       children.push(mirroredChild);
     }
 
-    this._children = children;
     return children;
   }
 }

src/nodes/mirrored/MirroredRegularNode.ts

@@ -19,3 +19,7 @@ export function isObjectLiteral(maybeObj: unknown): maybeObj is Dictionary<unkno
   const proto = Object.getPrototypeOf(maybeObj);
   return proto === null || proto === Object.prototype;
 }
+
+export function isNonNullable<T = unknown>(maybeNullable: T): maybeNullable is NonNullable<T> {
+  return maybeNullable !== void 0 && maybeNullable !== null;
+}

src/utils/guards.ts

@@ -3,7 +3,7 @@ import type { Dictionary } from '@stoplight/types';
 import createMagicError from 'magic-error';
 
 import { MergingError } from '../errors';
-import { isReferenceNode, isRegularNode, isRootNode } from '../guards';
+import { isMirroredNode, isReferenceNode, isRegularNode, isRootNode } from '../guards';
 import { mergeAllOf } from '../mergers/mergeAllOf';
 import { mergeOneOrAnyOf } from '../mergers/mergeOneOrAnyOf';
 import { MirroredReferenceNode, MirroredRegularNode, ReferenceNode, RegularNode } from '../nodes';
@@ -78,13 +78,28 @@ export class Walker extends EventEmitter<WalkerEmitter> {
   }
 
   public walk(): void {
-    const { depth: initialDepth, schemaNode: initialSchemaNode, fragment } = this;
+    const { depth: initialDepth, fragment } = this;
+    let { schemaNode: initialSchemaNode } = this;
 
     if (initialDepth === -1 && Object.keys(fragment).length === 0) {
       // empty schema, nothing to do
       return;
     }
 
+    while (isMirroredNode(initialSchemaNode)) {
+      if (!isRegularNode(initialSchemaNode.mirroredNode)) {
+        return;
+      }
+
+      if (initialSchemaNode.mirroredNode.children === void 0) {
+        this.restoreWalkerAtNode(initialSchemaNode.mirroredNode);
+        initialSchemaNode = this.schemaNode;
+        this.depth = initialDepth;
+      } else {
+        return;
+      }
+    }
+
     const state = this.dumpInternalWalkerState();
 
     super.emit('enterFragment', fragment);
@@ -110,10 +125,10 @@ export class Walker extends EventEmitter<WalkerEmitter> {
       }
 
       if ('children' in initialSchemaNode && !isRootNode(schemaNode)) {
-        if (initialSchemaNode.children === null) {
+        if (initialSchemaNode.children === void 0) {
           (initialSchemaNode as RegularNode).children = [schemaNode];
         } else {
-          initialSchemaNode.children.push(schemaNode);
+          initialSchemaNode.children!.push(schemaNode);
         }
       }