[0.21] Fix a bug that reuses the same ImportMap in fragments (#200)

Author: lorisleiva

.changeset/giant-dogs-scream.md

@@ -0,0 +1,5 @@
+---
+'@kinobi-so/renderers-js': patch
+---
+
+Fix a bug that reuses the same `ImportMap` within different code fragments

packages/renderers-js/src/fragments/common.ts

@@ -31,8 +31,8 @@ export class Fragment {
 
     constructor(render: string, imports?: ImportMap, features?: Set<FragmentFeature>) {
         this.render = render;
-        this.imports = imports ?? new ImportMap();
-        this.features = features ?? new Set();
+        this.imports = imports ? new ImportMap().mergeWith(imports) : new ImportMap();
+        this.features = new Set([...(features ?? [])]);
     }
 
     setRender(render: string): this {

packages/renderers-js/test/_setup.ts

@@ -21,6 +21,15 @@ export function renderMapContains(renderMap: RenderMap, key: string, expected: (
     return codeContains(renderMap.get(key), expected);
 }
 
+export function renderMapDoesNotContain(
+    renderMap: RenderMap,
+    key: string,
+    expected: (RegExp | string)[] | RegExp | string,
+) {
+    expect(renderMap.has(key), `RenderMap is missing key "${key}".`).toBe(true);
+    return codeDoesNotContain(renderMap.get(key), expected);
+}
+
 export async function codeContains(actual: string, expected: (RegExp | string)[] | RegExp | string) {
     const expectedArray = Array.isArray(expected) ? expected : [expected];
     const normalizedActual = await normalizeCode(actual);
@@ -50,6 +59,15 @@ export function renderMapContainsImports(renderMap: RenderMap, key: string, expe
     return codeContainsImports(renderMap.get(key), expectedImports);
 }
 
+export function renderMapDoesNotContainImports(
+    renderMap: RenderMap,
+    key: string,
+    expectedImports: Record<string, string[]>,
+) {
+    expect(renderMap.has(key), `RenderMap is missing key "${key}".`).toBe(true);
+    return codeDoesNotContainImports(renderMap.get(key), expectedImports);
+}
+
 export async function codeContainsImports(actual: string, expectedImports: Record<string, string[]>) {
     const normalizedActual = await inlineCode(actual);
     const importPairs = Object.entries(expectedImports).flatMap(([key, value]) => {
@@ -61,6 +79,17 @@ export async function codeContainsImports(actual: string, expectedImports: Recor
     });
 }
 
+export async function codeDoesNotContainImports(actual: string, expectedImports: Record<string, string[]>) {
+    const normalizedActual = await inlineCode(actual);
+    const importPairs = Object.entries(expectedImports).flatMap(([key, value]) => {
+        return value.map(v => [key, v] as const);
+    });
+
+    importPairs.forEach(([importFrom, importValue]) => {
+        expect(normalizedActual).not.toMatch(new RegExp(`import{[^}]*\\b${importValue}\\b[^}]*}from'${importFrom}'`));
+    });
+}
+
 export function codeStringAsRegex(code: string) {
     const stringAsRegex = escapeRegex(code)
         // Transform spaces between words into required whitespace.

packages/renderers-js/test/pdasPage.test.ts

@@ -1,6 +1,7 @@
 import {
     constantPdaSeedNodeFromString,
     numberTypeNode,
+    optionTypeNode,
     pdaNode,
     programNode,
     publicKeyTypeNode,
@@ -10,7 +11,7 @@ import { visit } from '@kinobi-so/visitors-core';
 import { test } from 'vitest';
 
 import { getRenderMapVisitor } from '../src';
-import { renderMapContains } from './_setup';
+import { renderMapContains, renderMapContainsImports, renderMapDoesNotContainImports } from './_setup';
 
 test('it renders a PDA helper function and its input type', async () => {
     // Given the following PDA node.
@@ -82,3 +83,30 @@ test('it renders an empty array of seeds for seedless PDAs', async () => {
         'getProgramDerivedAddress({ programAddress, seeds: [] })',
     ]);
 });
+
+test('it does not import strict types for variable seeds', async () => {
+    // Given the following PDA node.
+    const node = programNode({
+        name: 'myProgram',
+        pdas: [
+            pdaNode({
+                name: 'foo',
+                seeds: [variablePdaSeedNode('myAccount', optionTypeNode(publicKeyTypeNode()))],
+            }),
+        ],
+        publicKey: '1111',
+    });
+
+    // When we render it.
+    const renderMap = visit(node, getRenderMapVisitor());
+
+    // Then the `Option` string type should not be imported.
+    await renderMapDoesNotContainImports(renderMap, 'pdas/foo.ts', {
+        '@solana/web3.js': ['type Option'],
+    });
+
+    // But the `OptionOrNullable` loose type should be imported.
+    await renderMapContainsImports(renderMap, 'pdas/foo.ts', {
+        '@solana/web3.js': ['type OptionOrNullable'],
+    });
+});