feat: weakmap metadata

Author: P0lip

src/components/SchemaRow.tsx

@@ -2,7 +2,7 @@ import { IRowRendererOptions, Tree } from '@stoplight/tree-list';
 import cn from 'classnames';
 import * as React from 'react';
 
-import { metadataStore } from '../tree/metadata';
+import { getNodeMetadata, metadataStore } from '../tree/metadata';
 import { GoToRefHandler, SchemaTreeListNode } from '../types';
 import { Caret, Description, Divider, Property, Validations } from './shared';
 
@@ -18,15 +18,10 @@ const ICON_DIMENSION = 20;
 const ROW_OFFSET = 7;
 
 export const SchemaRow: React.FunctionComponent<ISchemaRow> = ({ className, node, rowOptions, onGoToRef }) => {
-  const metadata = metadataStore[node.id];
-  if (!metadata) {
-    throw new Error('Missing metadata');
-  }
-
+  const metadata = getNodeMetadata(node);
   const { path, schema: schemaNode } = metadata;
 
-  const parentSchemaNode =
-    node.parent === null || !(node.parent.id in metadataStore) ? null : metadataStore[node.parent.id].schema;
+  const parentSchemaNode = (node.parent !== null && metadataStore.get(node.parent)?.schema) || null;
   const description = 'annotations' in schemaNode ? schemaNode.annotations.description : null;
 
   return (

src/components/__tests__/Type.spec.tsx

@@ -5,14 +5,14 @@ import { IType, PropertyTypeColors, Type } from '../shared/Types';
 
 describe('Type component', () => {
   it.each(Object.keys(PropertyTypeColors))('should handle $s type', type => {
-    const wrapper = shallow(<Type type={type as IType['type']} />);
+    const wrapper = shallow(<Type type={type as IType['type']} subtype={void 0} />);
 
     expect(wrapper).toHaveText(type);
   });
 
   it('should handle unknown types', () => {
     // @ts-ignore
-    const wrapper = shallow(<Type type="foo" />);
+    const wrapper = shallow(<Type type="foo" subtype={void 0} />);
 
     expect(wrapper).toHaveText('foo');
   });

src/components/shared/Types.tsx

@@ -9,7 +9,7 @@ import { JSONSchema4CombinerName } from '../../types';
  * TYPE
  */
 export interface IType {
-  type: JSONSchema4TypeName | JSONSchema4CombinerName | '$ref';
+  type: JSONSchema4TypeName | JSONSchema4CombinerName | 'binary' | '$ref';
   subtype: Optional<JSONSchema4TypeName | JSONSchema4TypeName[]>;
   className?: string;
 }
@@ -75,7 +75,7 @@ export const PropertyTypeColors: Dictionary<string, IType['type']> = {
   integer: 'text-red-7 dark:text-red-6',
   number: 'text-red-7 dark:text-red-6',
   boolean: 'text-red-4',
-  // binary: 'text-green-4',
+  binary: 'text-green-4',
   string: 'text-green-7 dark:text-green-5',
   $ref: 'text-purple-6 dark:text-purple-4',
 };

src/tree/metadata.ts

@@ -1,9 +1,19 @@
 import { JsonPath } from '@stoplight/types';
 import { SchemaNode, SchemaTreeListNode } from '../types';
+import { TreeListNode } from '@stoplight/tree-list';
 
 export interface ITreeNodeMeta {
   path: JsonPath;
   schema: SchemaNode;
 }
 
 export const metadataStore = new WeakMap<SchemaTreeListNode, ITreeNodeMeta>();
+
+export const getNodeMetadata = (node: TreeListNode): ITreeNodeMeta => {
+  const metadata = metadataStore.get(node);
+  if (metadata === void 0) {
+    throw new Error('Missing metadata');
+  }
+
+  return metadata;
+}

src/tree/populateTree.ts

@@ -19,9 +19,9 @@ export type Walker = (
   level: number,
   path: JsonPath,
   options: WalkingOptions | null,
-) => void;
+) => undefined;
 
-export const populateTree: Walker = (schema, parent, level, path, options) => {
+export const populateTree: Walker = (schema, parent, level, path, options): undefined => {
   if (typeof schema !== 'object' || schema === null) return;
 
   for (const node of walk(schema)) {
@@ -34,10 +34,10 @@ export const populateTree: Walker = (schema, parent, level, path, options) => {
     };
 
     parent.children.push(treeNode);
-    metadataStore[treeNode.id] = {
+    metadataStore.set(treeNode, {
       schema: node,
       path,
-    };
+    });
 
     if (isRefNode(node) && isLocalRef(node.$ref) && node.$ref !== '#') {
       (treeNode as TreeListParentNode).children = [];

src/tree/tree.ts

@@ -5,7 +5,7 @@ import { JSONSchema4 } from 'json-schema';
 import { get } from 'lodash-es';
 import { SchemaNode } from '../types';
 import { isRefNode } from '../utils/guards';
-import { metadataStore } from './metadata';
+import { getNodeMetadata, metadataStore } from './metadata';
 import { populateTree } from './populateTree';
 
 export class SchemaTree extends Tree {
@@ -23,7 +23,9 @@ export class SchemaTree extends Tree {
           expanded[node.id] = false;
         }
 
-        if (metadataStore[parentTreeNode.id] && isRefNode(metadataStore[parentTreeNode.id].schema)) return false;
+        const metadata = metadataStore.get(parentTreeNode);
+
+        if (metadata !== void 0 && isRefNode(metadata.schema)) return false;
         return level <= this.defaultExpandedDepth + 1;
       },
     });
@@ -45,9 +47,9 @@ export class SchemaTree extends Tree {
       return super.unwrap(node);
     }
 
-    const { path, schema } = metadataStore[node.id];
+    const { path, schema } = getNodeMetadata(node);
     if (isRefNode(schema)) {
-      this.populateTreeFragment(node, pointerToPath(schema.$ref)); // DO NOTE THAT NODES PLACED UNDER THE REF WON'T HAVE CORREC PATHS
+      this.populateTreeFragment(node, pointerToPath(schema.$ref)); // DO NOTE THAT NODES PLACED UNDER THE REF MAY NOT HAVE CORRECT PATHS
     } else {
       this.populateTreeFragment(node, path);
     }

src/utils/__tests__/renderSchema.spec.ts

@@ -1,6 +1,6 @@
 import * as fs from 'fs';
 import * as path from 'path';
-import { generateTree } from '../../tree/renderSchema';
+import { generateTree } from '../../tree/G';
 
 const BASE_PATH = path.resolve(__dirname, '../../__fixtures__/');