feat: placement api

Author: mrlubos

packages/codegen-core/src/__tests__/bimap.test.ts

@@ -0,0 +1,66 @@
+import { describe, expect, it } from 'vitest';
+
+import { BiMap } from '../bimap/bimap';
+
+describe('BiMap', () => {
+  it('covers the full public interface', () => {
+    const bimap = new BiMap<number, string>();
+    // set and get
+    expect(bimap.set(1, 'a')).toBe(bimap);
+    expect(bimap.set(2, 'b')).toBe(bimap);
+    // get, getKey
+    expect(bimap.get(1)).toBe('a');
+    expect(bimap.get(2)).toBe('b');
+    expect(bimap.getKey('a')).toBe(1);
+    expect(bimap.getKey('b')).toBe(2);
+    // hasKey, hasValue
+    expect(bimap.hasKey(1)).toBe(true);
+    expect(bimap.hasKey(2)).toBe(true);
+    expect(bimap.hasKey(3)).toBe(false);
+    expect(bimap.hasValue('a')).toBe(true);
+    expect(bimap.hasValue('b')).toBe(true);
+    expect(bimap.hasValue('c')).toBe(false);
+    // keys, values, entries
+    expect(Array.from(bimap.keys())).toEqual([1, 2]);
+    expect(Array.from(bimap.values())).toEqual(['a', 'b']);
+    expect(Array.from(bimap.entries())).toEqual([
+      [1, 'a'],
+      [2, 'b'],
+    ]);
+    // Symbol.iterator
+    expect(Array.from(bimap)).toEqual([
+      [1, 'a'],
+      [2, 'b'],
+    ]);
+    // size
+    expect(bimap.size).toBe(2);
+    // delete by key
+    expect(bimap.delete(1)).toBe(true);
+    expect(bimap.hasKey(1)).toBe(false);
+    expect(bimap.hasValue('a')).toBe(false);
+    // delete by value
+    expect(bimap.deleteValue('b')).toBe(true);
+    expect(bimap.hasKey(2)).toBe(false);
+    expect(bimap.hasValue('b')).toBe(false);
+    // After all deletes
+    expect(bimap.size).toBe(0);
+    // Setting again to check overwrite
+    bimap.set(1, 'x');
+    bimap.set(2, 'y');
+    expect(bimap.get(1)).toBe('x');
+    expect(bimap.get(2)).toBe('y');
+    // Overwrite value for existing key
+    bimap.set(1, 'z');
+    expect(bimap.get(1)).toBe('z');
+    expect(bimap.getKey('z')).toBe(1);
+    // Overwrite key for existing value
+    bimap.set(3, 'z');
+    expect(bimap.getKey('z')).toBe(3);
+    expect(bimap.get(1)).toBeUndefined();
+    // Iteration after overwrite
+    expect(Array.from(bimap)).toEqual([
+      [2, 'y'],
+      [3, 'z'],
+    ]);
+  });
+});

packages/codegen-core/src/__tests__/bindings.test.ts

@@ -0,0 +1,226 @@
+import { describe, expect, it } from 'vitest';
+
+import type { IBiMap } from '../bimap/types';
+import type { IBinding } from '../bindings/types';
+import { createBinding, mergeBindings } from '../bindings/utils';
+import type { ISymbolMeta } from '../extensions/types';
+import type { IFileOut } from '../files/types';
+import type { ISymbolOut } from '../symbols/types';
+
+function makeBiMap(entries: [number, string][] = []): IBiMap<number, string> {
+  const map = new Map<number, string>(entries);
+  const reverse = new Map<string, number>(entries.map(([k, v]) => [v, k]));
+  const bimap: IBiMap<number, string> = {
+    delete: (key: number) => {
+      const value = map.get(key);
+      map.delete(key);
+      if (value) reverse.delete(value);
+      return true;
+    },
+    deleteValue: (value: string) => {
+      const key = reverse.get(value);
+      reverse.delete(value);
+      if (key) map.delete(key);
+      return true;
+    },
+    entries: () => map.entries(),
+    get: (key: number) => map.get(key),
+    getKey: (value: string) => reverse.get(value),
+    hasKey: (key: number) => map.has(key),
+    hasValue: (value: string) => reverse.has(value),
+    keys() {
+      return map.keys();
+    },
+    set: (key: number, value: string): IBiMap<number, string> => {
+      map.set(key, value);
+      reverse.set(value, key);
+      return bimap;
+    },
+    size: 0,
+    values() {
+      return map.values();
+    },
+    [Symbol.iterator]() {
+      return map[Symbol.iterator]();
+    },
+  };
+  return bimap;
+}
+
+const makeFile = (
+  resolvedNames: IBiMap<number, string> = makeBiMap(),
+  id: number = 1,
+): IFileOut => ({
+  extension: 'ts',
+  id,
+  name: '',
+  path: '',
+  resolvedNames,
+  selector: [],
+  symbols: { body: [], exports: [], imports: [] },
+});
+
+const makeSymbol = (
+  id: number,
+  placeholder: string,
+  meta: ISymbolMeta = {},
+  name?: string,
+): ISymbolOut => ({
+  exportFrom: [],
+  id,
+  meta,
+  name,
+  placeholder,
+});
+
+describe('createBinding', () => {
+  it('creates a named binding by default', () => {
+    const file = makeFile(makeBiMap([[1, 'Foo']]));
+    const symbol = makeSymbol(
+      1,
+      'Foo',
+      { importKind: 'named', kind: 'value' },
+      'Foo',
+    );
+    const symbolFile = makeFile(makeBiMap([[1, 'Foo']]));
+    const binding = createBinding({
+      file,
+      modulePath: './foo',
+      symbol,
+      symbolFile,
+    });
+    expect(binding).toEqual({
+      aliases: {},
+      from: './foo',
+      names: ['Foo'],
+      typeNames: [],
+    });
+  });
+
+  it('creates a default binding', () => {
+    const file = makeFile();
+    const symbol = makeSymbol(
+      2,
+      'Bar',
+      { importKind: 'default', kind: 'value' },
+      'Bar',
+    );
+    const symbolFile = makeFile();
+    const binding = createBinding({
+      file,
+      modulePath: './bar',
+      symbol,
+      symbolFile,
+    });
+    expect(binding).toEqual({
+      aliases: {},
+      defaultBinding: 'Bar',
+      from: './bar',
+      names: [],
+      typeDefaultBinding: undefined,
+      typeNames: [],
+    });
+  });
+
+  it('creates a namespace binding', () => {
+    const file = makeFile();
+    const symbol = makeSymbol(
+      3,
+      'Baz',
+      { importKind: 'namespace', kind: 'value' },
+      'Baz',
+    );
+    const symbolFile = makeFile();
+    const binding = createBinding({
+      file,
+      modulePath: './baz',
+      symbol,
+      symbolFile,
+    });
+    expect(binding).toEqual({
+      aliases: {},
+      from: './baz',
+      names: [],
+      namespaceBinding: 'Baz',
+      typeNames: [],
+      typeNamespaceBinding: undefined,
+    });
+  });
+
+  it('creates type names for type symbols', () => {
+    const file = makeFile(makeBiMap([[4, 'Qux']]));
+    const symbol = makeSymbol(
+      4,
+      'Qux',
+      { importKind: 'named', kind: 'type' },
+      'Qux',
+    );
+    const symbolFile = makeFile(makeBiMap([[4, 'Qux']]));
+    const binding = createBinding({
+      file,
+      modulePath: './qux',
+      symbol,
+      symbolFile,
+    });
+    expect(binding).toEqual({
+      aliases: {},
+      from: './qux',
+      names: ['Qux'],
+      typeNames: ['Qux'],
+    });
+  });
+});
+
+describe('mergeBindings', () => {
+  it('merges aliases, names, and typeNames', () => {
+    const target: IBinding = {
+      aliases: { Foo: 'Bar' },
+      from: './foo',
+      names: ['Foo'],
+      typeNames: ['Foo'],
+    };
+    const source: IBinding = {
+      aliases: { Baz: 'Qux' },
+      from: './foo',
+      names: ['Baz'],
+      typeNames: ['Baz'],
+    };
+    mergeBindings(target, source);
+    expect(target).toEqual({
+      aliases: { Baz: 'Qux', Foo: 'Bar' },
+      from: './foo',
+      names: ['Foo', 'Baz'],
+      typeNames: ['Foo', 'Baz'],
+    });
+  });
+
+  it('merges default and namespace bindings', () => {
+    const target: IBinding = {
+      aliases: {},
+      from: './foo',
+      names: [],
+      typeNames: [],
+    };
+    const source: IBinding = {
+      aliases: {},
+      defaultBinding: 'Default',
+      from: './foo',
+      names: [],
+      namespaceBinding: 'NS',
+      typeDefaultBinding: true,
+      typeNames: [],
+      typeNamespaceBinding: true,
+    };
+    mergeBindings(target, source);
+    expect(target).toEqual({
+      aliases: {},
+      defaultBinding: 'Default',
+      from: './foo',
+      names: [],
+      namespaceBinding: 'NS',
+      typeDefaultBinding: true,
+      typeNames: [],
+      typeNamespaceBinding: true,
+    });
+  });
+});

packages/codegen-core/src/__tests__/file.ts renamed to packages/codegen-core/src/__tests__/data/file.ts

@@ -0,0 +1,29 @@
+import { describe, expect, it } from 'vitest';
+
+import * as index from '../index';
+
+const constExports = ['createBinding', 'mergeBindings', 'Project', 'renderIds'];
+
+// Type-level test: will fail to compile if any type export is missing or renamed
+export type _TypeExports = [
+  index.BiMap<string, string>,
+  index.Binding,
+  index.ProjectRenderMeta,
+  index.SymbolMeta,
+  index.File,
+  index.FileIn,
+  index.Output,
+  index.IProject,
+  index.Renderer,
+  index.Selector,
+  index.Symbol,
+  index.SymbolIn,
+];
+
+describe('index exports', () => {
+  it('should export all expected symbols', () => {
+    for (const key of constExports) {
+      expect(index).toHaveProperty(key);
+    }
+  });
+});