feat(nodes): implement Symbol.hasInstance

Author: P0lip

src/__tests__/utils/printTree.ts

@@ -2,8 +2,8 @@ import { pathToPointer } from '@stoplight/json';
 import type { Dictionary } from '@stoplight/types';
 import * as treeify from 'treeify';
 
-import { isMirroredNode, isRegularNode } from '../../guards';
-import { MirroredSchemaNode, ReferenceNode, RegularNode, SchemaNode } from '../../nodes';
+import { isMirroredNode, isReferenceNode, isRegularNode } from '../../guards';
+import type { MirroredSchemaNode, ReferenceNode, RegularNode, SchemaNode } from '../../nodes';
 import type { SchemaTreeOptions } from '../../tree';
 import { SchemaTree } from '../../tree';
 import type { SchemaFragment } from '../../types';
@@ -54,9 +54,9 @@ function printMirrorNode(this: WeakSet<SchemaFragment>, node: MirroredSchemaNode
 function printNode(this: WeakSet<SchemaFragment>, node: SchemaNode) {
   return isMirroredNode(node)
     ? printMirrorNode.call(this, node)
-    : node instanceof RegularNode
+    : isRegularNode(node)
     ? printRegularNode.call(this, node)
-    : node instanceof ReferenceNode
+    : isReferenceNode(node)
     ? printReferenceNode.call(this, node)
     : {
         kind: 'unknown node',

src/guards/nodes.ts

@@ -1,4 +1,27 @@
-import type { MirroredSchemaNode, ReferenceNode, RegularNode, SchemaNode } from '../nodes';
+import {
+  MirroredReferenceNode,
+  MirroredRegularNode,
+  MirroredSchemaNode,
+  ReferenceNode,
+  RegularNode,
+  RootNode,
+  SchemaNode,
+} from '../nodes';
+
+export function isSchemaNode(node: unknown): node is SchemaNode {
+  const name = Object.getPrototypeOf(node).constructor.name;
+  return (
+    name === RootNode.name ||
+    name === RegularNode.name ||
+    name === MirroredRegularNode.name ||
+    name === ReferenceNode.name ||
+    name === MirroredReferenceNode.name
+  );
+}
+
+export function isRootNode(node: SchemaNode): node is RootNode {
+  return Object.getPrototypeOf(node).constructor.name === 'RootNode';
+}
 
 export function isRegularNode(node: SchemaNode): node is RegularNode {
   return 'types' in node && 'primaryType' in node && 'combiners' in node;

src/nodes/ReferenceNode.ts

@@ -1,6 +1,7 @@
 import { isLocalRef } from '@stoplight/json';
 
 import { unwrapStringOrNull } from '../accessors/unwrap';
+import { isReferenceNode, isSchemaNode } from '../guards';
 import type { SchemaFragment } from '../types';
 import { BaseNode } from './BaseNode';
 
@@ -16,4 +17,8 @@ export class ReferenceNode extends BaseNode {
   public get external() {
     return this.value !== null && !isLocalRef(this.value);
   }
+
+  static [Symbol.hasInstance](instance: unknown) {
+    return isSchemaNode(instance) && isReferenceNode(instance);
+  }
 }

src/nodes/RegularNode.ts

@@ -9,6 +9,7 @@ import { getTypes } from '../accessors/getTypes';
 import { getValidations } from '../accessors/getValidations';
 import { isDeprecated } from '../accessors/isDeprecated';
 import { unwrapArrayOrNull, unwrapStringOrNull } from '../accessors/unwrap';
+import { isRegularNode, isSchemaNode } from '../guards';
 import type { SchemaFragment } from '../types';
 import { BaseNode } from './BaseNode';
 import type { ReferenceNode } from './ReferenceNode';
@@ -66,4 +67,8 @@ export class RegularNode extends BaseNode {
       Object.keys(this.annotations).length + Object.keys(this.validations).length === 0
     );
   }
+
+  static [Symbol.hasInstance](instance: unknown) {
+    return isSchemaNode(instance) && isRegularNode(instance);
+  }
 }

src/nodes/__tests__/ReferenceNode.spec.ts

@@ -0,0 +1,15 @@
+import { MirroredReferenceNode } from '../mirrored';
+import { ReferenceNode } from '../ReferenceNode';
+import { RegularNode } from '../RegularNode';
+
+describe('ReferenceNode node', () => {
+  it('should have a working Symbol.hasInstance trait', () => {
+    const referenceNode = new ReferenceNode({ $ref: '' }, null);
+    const mirroredNode = new MirroredReferenceNode(referenceNode);
+
+    expect(mirroredNode instanceof ReferenceNode).toBe(true);
+    expect(referenceNode instanceof ReferenceNode).toBe(true);
+    expect(mirroredNode instanceof RegularNode).toBe(false);
+    expect(referenceNode instanceof RegularNode).toBe(false);
+  });
+});

src/nodes/__tests__/RegularNode.spec.ts

@@ -0,0 +1,15 @@
+import { MirroredRegularNode } from '../mirrored';
+import { ReferenceNode } from '../ReferenceNode';
+import { RegularNode } from '../RegularNode';
+
+describe('RegularNode node', () => {
+  it('should have a working Symbol.hasInstance trait', () => {
+    const regularNode = new RegularNode({ type: 'string' });
+    const mirroredNode = new MirroredRegularNode(regularNode);
+
+    expect(mirroredNode instanceof RegularNode).toBe(true);
+    expect(regularNode instanceof RegularNode).toBe(true);
+    expect(mirroredNode instanceof ReferenceNode).toBe(false);
+    expect(regularNode instanceof ReferenceNode).toBe(false);
+  });
+});

src/nodes/mirrored/index.ts

@@ -1,2 +1,2 @@
-export * from './MirroredReferenceNode';
-export * from './MirroredRegularNode';
+export { MirroredReferenceNode } from './MirroredReferenceNode';
+export { MirroredRegularNode } from './MirroredRegularNode';

src/walker/walker.ts

@@ -3,11 +3,11 @@ import type { Dictionary } from '@stoplight/types';
 import createMagicError from 'magic-error';
 
 import { MergingError } from '../errors';
-import { isReferenceNode, isRegularNode } from '../guards';
+import { isReferenceNode, isRegularNode, isRootNode } from '../guards';
 import { mergeAllOf } from '../mergers/mergeAllOf';
 import { mergeOneOrAnyOf } from '../mergers/mergeOneOrAnyOf';
 import { MirroredReferenceNode, MirroredRegularNode, ReferenceNode, RegularNode } from '../nodes';
-import { RootNode } from '../nodes/RootNode';
+import type { RootNode } from '../nodes/RootNode';
 import { SchemaCombinerName, SchemaNode, SchemaNodeKind } from '../nodes/types';
 import type { SchemaFragment } from '../types';
 import { isObjectLiteral } from '../utils/guards';
@@ -104,12 +104,12 @@ export class Walker extends EventEmitter<WalkerEmitter> {
         continue;
       }
 
-      if (!(schemaNode instanceof RootNode)) {
+      if (!isRootNode(schemaNode)) {
         schemaNode.parent = initialSchemaNode;
         schemaNode.subpath = this.path.slice(initialSchemaNode.path.length);
       }
 
-      if ('children' in initialSchemaNode && !(schemaNode instanceof RootNode)) {
+      if ('children' in initialSchemaNode && !isRootNode(schemaNode)) {
         if (initialSchemaNode.children === null) {
           (initialSchemaNode as RegularNode).children = [schemaNode];
         } else {
@@ -119,7 +119,7 @@ export class Walker extends EventEmitter<WalkerEmitter> {
 
       super.emit('includeNode', schemaNode);
 
-      if (schemaNode instanceof RegularNode) {
+      if (isRegularNode(schemaNode)) {
         this.schemaNode = schemaNode;
 
         if (this.hooks.stepIn?.(schemaNode) !== false) {