feat: lazyInlineResolver util

src/__tests__/lazyInlineRefResolver.spec.ts

@@ -0,0 +1,25 @@
+import { lazyInlineRefResolver } from '../lazyInlineRefResolver';
+
+describe('lazyInlineResolver', () => {
+  test('should work', () => {
+    const doc = {
+      a: {
+        $ref: '#/b/foo',
+      },
+      b: {
+        foo: {
+          $ref: '#/c',
+        },
+        bar: {
+          $ref: '#/e',
+        },
+      },
+      c: {
+        $ref: '#/b/bar',
+      },
+      e: 'woo!',
+    };
+
+    expect((lazyInlineRefResolver(doc) as any).b.foo).toBe('woo!');
+  });
+});

src/index.ts

@@ -11,6 +11,7 @@ export * from './getLastPathSegment';
 export * from './getLocationForJsonPath';
 export * from './hasRef';
 export * from './isLocalRef';
+export * from './lazyInlineRefResolver';
 export * from './parseWithPointers';
 export * from './pathToPointer';
 export * from './pointerToPath';

src/lazyInlineRefResolver.ts

@@ -0,0 +1,38 @@
+import { resolveInlineRef } from './resolveInlineRef';
+
+const ROOT_MAP = new WeakMap();
+
+type Root = Record<PropertyKey, unknown>;
+
+// todo: handle circular? might be not needed, as simply pass the responsibility onto consumer
+const traps: ProxyHandler<Root> = {
+  get(target, key, recv) {
+    const value = Reflect.get(target, key, recv);
+
+    if (typeof value === 'object' && value !== null) {
+      const root = ROOT_MAP.get(target);
+
+      if (!('$ref' in value)) {
+        return _lazyInlineRefResolver(value, root);
+      }
+
+      const resolved = resolveInlineRef(root, value.$ref);
+      if (typeof resolved === 'object' && resolved !== null) {
+        return _lazyInlineRefResolver(resolved, root);
+      }
+
+      return resolved;
+    }
+
+    return value;
+  },
+};
+
+function _lazyInlineRefResolver(obj: object, root: Root) {
+  ROOT_MAP.set(obj, root);
+  return new Proxy(obj, traps);
+}
+
+export function lazyInlineRefResolver(root: Root) {
+  return _lazyInlineRefResolver(root, root);
+}