@metaplex-foundation/kinobi 0.0.1

package/src/renderers/js/GetJavaScriptValidatorBagVisitor.ts

@@ -0,0 +1,202 @@
+import { camelCase, pascalCase, titleCase } from '../../utils';
+import * as nodes from '../../nodes';
+import {
+  GetDefaultValidatorBagVisitor,
+  NodeStack,
+  ValidatorBag,
+} from '../../visitors';
+
+export class GetJavaScriptValidatorBagVisitor extends GetDefaultValidatorBagVisitor {
+  protected exportMap: Map<
+    string,
+    { node: nodes.Node; stack: NodeStack; exportType: string }
+  > = new Map();
+
+  visitRoot(root: nodes.RootNode): ValidatorBag {
+    return super.visitRoot(root);
+  }
+
+  visitProgram(program: nodes.ProgramNode): ValidatorBag {
+    const bag = super.visitProgram(program);
+    this.pushNode(program);
+    const pascalCaseName = pascalCase(program.name);
+    bag.mergeWith([
+      this.checkExportConflicts(program, {
+        [`get${pascalCaseName}Program`]: 'function',
+        [`get${pascalCaseName}ErrorFromCode`]: 'function',
+        [`get${pascalCaseName}ErrorFromName`]: 'function',
+      }),
+    ]);
+    this.popNode();
+    return bag;
+  }
+
+  visitAccount(account: nodes.AccountNode): ValidatorBag {
+    const bag = super.visitAccount(account);
+    this.pushNode(account);
+    const exports = {
+      [account.name]: 'type',
+      [`${account.name}AccountData`]: 'type',
+      [`${account.name}AccountArgs`]: 'type',
+      [`fetch${account.name}`]: 'function',
+      [`safeFetch${account.name}`]: 'function',
+      [`deserialize${account.name}`]: 'function',
+      [`get${account.name}AccountDataSerializer`]: 'function',
+      [`get${account.name}Size`]: 'function',
+    };
+    if (account.metadata.seeds.length > 0) {
+      exports[`find${account.name}Pda`] = 'function';
+    }
+    bag.mergeWith([this.checkExportConflicts(account, exports)]);
+    const reservedAccountFields = new Set(['publicKey', 'header']);
+    const invalidFields = account.type.fields
+      .map((field) => field.name)
+      .filter((name) => reservedAccountFields.has(name));
+    if (invalidFields.length > 0) {
+      const x = invalidFields.join(', ');
+      const message =
+        invalidFields.length === 1
+          ? `Account field [${x}] is reserved. Please rename it.`
+          : `Account fields [${x}] are reserved. Please rename them.`;
+      bag.error(message, account, this.stack);
+    }
+    this.popNode();
+    return bag;
+  }
+
+  visitInstruction(instruction: nodes.InstructionNode): ValidatorBag {
+    const bag = super.visitInstruction(instruction);
+    this.pushNode(instruction);
+    bag.mergeWith([
+      this.checkExportConflicts(instruction, {
+        [camelCase(instruction.name)]: 'function',
+        [`${instruction.name}InstructionAccounts`]: 'type',
+        [`${instruction.name}InstructionData`]: 'type',
+        [`${instruction.name}InstructionArgs`]: 'type',
+        [`get${instruction.name}InstructionDataSerializer`]: 'function',
+      }),
+    ]);
+    this.popNode();
+    return bag;
+  }
+
+  visitDefinedType(definedType: nodes.DefinedTypeNode): ValidatorBag {
+    const bag = super.visitDefinedType(definedType);
+    this.pushNode(definedType);
+    const isDataEnum =
+      nodes.isTypeEnumNode(definedType.type) && definedType.type.isDataEnum();
+    bag.mergeWith([
+      this.checkExportConflicts(definedType, {
+        [definedType.name]: 'type',
+        [`${definedType.name}Args`]: 'type',
+        [`fetch${definedType.name}`]: 'function',
+        ...(isDataEnum
+          ? {
+              [camelCase(definedType.name)]: 'function',
+              [`is${definedType.name}`]: 'function',
+            }
+          : {}),
+      }),
+    ]);
+    this.popNode();
+    return bag;
+  }
+
+  visitError(error: nodes.ErrorNode): ValidatorBag {
+    const bag = super.visitError(error);
+    this.pushNode(error);
+    const prefixedName =
+      pascalCase(this.program?.metadata.prefix ?? '') +
+      pascalCase(error.metadata.name);
+    bag.mergeWith([
+      this.checkExportConflicts(error, {
+        [`${prefixedName}Error`]: 'class',
+      }),
+    ]);
+    this.popNode();
+    return bag;
+  }
+
+  visitTypeLeafWrapper(
+    typeLeafWrapper: nodes.TypeLeafWrapperNode
+  ): ValidatorBag {
+    const bag = super.visitTypeLeafWrapper(typeLeafWrapper);
+    this.pushNode(typeLeafWrapper);
+    const { wrapper, leaf } = typeLeafWrapper;
+    switch (wrapper.kind) {
+      case 'DateTime':
+        if (!leaf.isInteger()) {
+          bag.error(
+            `DateTime wrapper can only be applied to ` +
+              `integer types. Got type [${leaf.type}].`,
+            typeLeafWrapper,
+            this.stack
+          );
+        }
+        break;
+      case 'Amount':
+        if (!leaf.isUnsignedInteger()) {
+          bag.error(
+            `Amount wrapper can only be applied to ` +
+              `unsigned integer types. Got type [${leaf.type}].`,
+            typeLeafWrapper,
+            this.stack
+          );
+        }
+        break;
+      default:
+        break;
+    }
+    this.popNode();
+    return bag;
+  }
+
+  protected checkExportConflicts(
+    node: nodes.Node,
+    exports: Record<string, string>
+  ): ValidatorBag {
+    const bag = new ValidatorBag();
+    const stack = this.stack.clone();
+    const conflictingNodes: nodes.Node[] = [];
+    Object.entries(exports).forEach(([exportName, exportType]) => {
+      // Checks for conflicts.
+      const exportConflict = this.exportMap.get(exportName);
+      if (!exportConflict) {
+        this.exportMap.set(exportName, { node, stack, exportType });
+        return;
+      }
+
+      // Avoids throwing many similar error for the same kind of conflict.
+      const conflictingNode = exportConflict.node;
+      if (conflictingNodes.includes(conflictingNode)) return;
+      conflictingNodes.push(conflictingNode);
+
+      // Constructs the error message.
+      let exportDetails = '';
+      let conflictExportDetails = '';
+      if (!this.isEponymousExport(node, exportName)) {
+        exportDetails = `exports a "${exportName}" ${exportType} that `;
+      }
+      if (!this.isEponymousExport(conflictingNode, exportName)) {
+        conflictExportDetails = `"${exportName}" ${exportConflict.exportType} exported by the `;
+      }
+      const message =
+        `The ${this.getNodeTitle(node)} ${exportDetails}` +
+        `conflicts with the ${conflictExportDetails}` +
+        `${this.getNodeTitle(conflictingNode)}.\n` +
+        `|> Conflicting stack: ${exportConflict.stack}.`;
+      bag.error(message, node, stack);
+    });
+    return bag;
+  }
+
+  protected isEponymousExport(node: nodes.Node, exportName: string): boolean {
+    return exportName === ('name' in node ? node.name : '');
+  }
+
+  protected getNodeTitle(node: nodes.Node): string {
+    const name = 'name' in node ? node.name : '';
+    const type = titleCase(node.nodeClass.slice(0, -4)).toLowerCase();
+    return `"${name}" ${type}`;
+  }
+}

package/src/renderers/js/JavaScriptImportMap.ts

@@ -0,0 +1,89 @@
+import { Dependency } from '../../visitors';
+
+const DEFAULT_MODULE_MAP: Record<string, string> = {
+  core: '@metaplex-foundation/umi-core',
+  types: '../types',
+  errors: '../errors',
+};
+
+export class JavaScriptImportMap {
+  protected readonly _imports: Map<Dependency, Set<string>> = new Map();
+
+  protected readonly _aliases: Map<Dependency, Record<string, string>> =
+    new Map();
+
+  add(
+    module: Dependency,
+    imports: string | string[] | Set<string>
+  ): JavaScriptImportMap {
+    const currentImports = this._imports.get(module) ?? new Set();
+    const newImports = typeof imports === 'string' ? [imports] : imports;
+    newImports.forEach((i) => currentImports.add(i));
+    this._imports.set(module, currentImports);
+    return this;
+  }
+
+  remove(
+    module: Dependency,
+    imports: string | string[] | Set<string>
+  ): JavaScriptImportMap {
+    const currentImports = this._imports.get(module) ?? new Set();
+    const importsToRemove = typeof imports === 'string' ? [imports] : imports;
+    importsToRemove.forEach((i) => currentImports.delete(i));
+    if (currentImports.size === 0) {
+      this._imports.delete(module);
+    } else {
+      this._imports.set(module, currentImports);
+    }
+    return this;
+  }
+
+  mergeWith(...others: JavaScriptImportMap[]): JavaScriptImportMap {
+    others.forEach((other) => {
+      other._imports.forEach((imports, module) => {
+        this.add(module, imports);
+      });
+    });
+    return this;
+  }
+
+  addAlias(
+    module: Dependency,
+    name: string,
+    alias: string
+  ): JavaScriptImportMap {
+    const currentAliases = this._aliases.get(module) ?? {};
+    currentAliases[name] = alias;
+    this._aliases.set(module, currentAliases);
+    return this;
+  }
+
+  isEmpty(): boolean {
+    return this._imports.size === 0;
+  }
+
+  toString(dependencies: Record<Dependency, string>): string {
+    const dependencyMap = { ...DEFAULT_MODULE_MAP, ...dependencies };
+    const importStatements = [...this._imports.entries()]
+      .map(([module, imports]) => {
+        const mappedModule: string = dependencyMap[module] ?? module;
+        return [mappedModule, module, imports] as const;
+      })
+      .sort(([a], [b]) => {
+        const aIsRelative = a.startsWith('.');
+        const bIsRelative = b.startsWith('.');
+        if (aIsRelative && !bIsRelative) return 1;
+        if (!aIsRelative && bIsRelative) return -1;
+        return a.localeCompare(b);
+      })
+      .map(([mappedModule, module, imports]) => {
+        const aliasMap = this._aliases.get(module) ?? {};
+        const joinedImports = [...imports]
+          .sort()
+          .map((i) => (aliasMap[i] ? `${i} as ${aliasMap[i]}` : i))
+          .join(', ');
+        return `import { ${joinedImports} } from '${mappedModule}';`;
+      });
+    return importStatements.join('\n');
+  }
+}

package/src/renderers/js/RenderJavaScriptValueNode.ts

@@ -0,0 +1,110 @@
+import * as nodes from '../../nodes';
+import { camelCase, mainCase, pascalCase } from '../../utils';
+import { JavaScriptImportMap } from './JavaScriptImportMap';
+
+export function renderJavaScriptValueNode(
+  value: nodes.ValueNode,
+  types: Map<string, nodes.DefinedTypeNode>
+): {
+  imports: JavaScriptImportMap;
+  render: string;
+} {
+  const imports = new JavaScriptImportMap();
+  switch (value.__kind) {
+    case 'list':
+    case 'tuple':
+      const list = value.values.map((v) => renderJavaScriptValueNode(v, types));
+      return {
+        imports: imports.mergeWith(...list.map((c) => c.imports)),
+        render: `[${list.map((c) => c.render).join(', ')}]`,
+      };
+    case 'set':
+      const set = value.values.map((v) => renderJavaScriptValueNode(v, types));
+      return {
+        imports: imports.mergeWith(...set.map((c) => c.imports)),
+        render: `new Set([${set.map((c) => c.render).join(', ')}])`,
+      };
+    case 'map':
+      const map = value.values.map(([k, v]) => {
+        const mapKey = renderJavaScriptValueNode(k, types);
+        const mapValue = renderJavaScriptValueNode(v, types);
+        return {
+          imports: mapKey.imports.mergeWith(mapValue.imports),
+          render: `[${mapKey.render}, ${mapValue.render}]`,
+        };
+      });
+      return {
+        imports: imports.mergeWith(...map.map((c) => c.imports)),
+        render: `new Map([${map.map((c) => c.render).join(', ')}])`,
+      };
+    case 'struct':
+      const struct = Object.entries(value.values).map(([k, v]) => {
+        const structValue = renderJavaScriptValueNode(v, types);
+        return {
+          imports: structValue.imports,
+          render: `${k}: ${structValue.render}`,
+        };
+      });
+      return {
+        imports: imports.mergeWith(...struct.map((c) => c.imports)),
+        render: `{ ${struct.map((c) => c.render).join(', ')} }`,
+      };
+    case 'enum':
+      const definedType = types.get(mainCase(value.enumType));
+      if (!definedType || !nodes.isTypeEnumNode(definedType.type)) {
+        throw new Error(`Cannot find enum ${value.enumType}.`);
+      }
+
+      const enumName = pascalCase(definedType.type.name);
+      const variantName = pascalCase(value.variant);
+      const rawDependency = value.dependency ?? definedType.metadata.importFrom;
+      const dependency =
+        rawDependency === 'generated' ? 'generatedTypes' : rawDependency;
+
+      if (definedType.type.isScalarEnum()) {
+        return {
+          imports: imports.add(dependency, enumName),
+          render: `${enumName}.${variantName}`,
+        };
+      }
+
+      const enumFn = camelCase(definedType.type.name);
+      imports.add(dependency, enumFn);
+
+      if (!value.value) {
+        return { imports, render: `${enumFn}('${variantName}')` };
+      }
+
+      const enumValue = renderJavaScriptValueNode(value.value, types);
+      const fields = enumValue.render;
+      imports.mergeWith(enumValue.imports);
+
+      return {
+        imports,
+        render: `${enumFn}('${variantName}', ${fields})`,
+      };
+    case 'optionSome':
+      const child = renderJavaScriptValueNode(value.value, types);
+      return {
+        imports: child.imports.add('core', 'some'),
+        render: `some(${child.render})`,
+      };
+    case 'optionNone':
+      return {
+        imports: new JavaScriptImportMap().add('core', 'none'),
+        render: 'none()',
+      };
+    case 'publicKey':
+      return {
+        imports: new JavaScriptImportMap().add('core', 'publicKey'),
+        render: `publicKey("${value.value}")`,
+      };
+    case 'string':
+    case 'number':
+    case 'boolean':
+      return { imports, render: JSON.stringify(value.value) };
+    default:
+      const neverDefault: never = value;
+      throw new Error(`Unexpected value type ${(neverDefault as any).__kind}`);
+  }
+}

package/src/renderers/js/RenderJavaScriptVisitor.ts

@@ -0,0 +1,45 @@
+import { LogLevel } from '../../logs';
+import * as nodes from '../../nodes';
+import { BaseThrowVisitor, ThrowValidatorItemsVisitor } from '../../visitors';
+import { deleteFolder } from '../utils';
+import { WriteRenderMapVisitor } from '../WriteRenderMapVisitor';
+import {
+  GetJavaScriptRenderMapOptions,
+  GetJavaScriptRenderMapVisitor,
+} from './GetJavaScriptRenderMapVisitor';
+import { GetJavaScriptValidatorBagVisitor } from './GetJavaScriptValidatorBagVisitor';
+
+export type RenderJavaScriptOptions = GetJavaScriptRenderMapOptions & {
+  deleteFolderBeforeRendering?: boolean;
+  throwLevel?: LogLevel;
+};
+
+export class RenderJavaScriptVisitor extends BaseThrowVisitor<void> {
+  constructor(
+    readonly path: string,
+    readonly options: RenderJavaScriptOptions = {}
+  ) {
+    super();
+  }
+
+  visitRoot(root: nodes.RootNode): void {
+    // Validate nodes.
+    root.accept(
+      new ThrowValidatorItemsVisitor(
+        new GetJavaScriptValidatorBagVisitor(),
+        this.options.throwLevel
+      )
+    );
+
+    // Delete existing generated folder.
+    if (this.options.deleteFolderBeforeRendering ?? true) {
+      deleteFolder(this.path);
+    }
+
+    // Render the new files.
+    new WriteRenderMapVisitor(
+      new GetJavaScriptRenderMapVisitor(this.options),
+      this.path
+    ).visitRoot(root);
+  }
+}

package/src/renderers/js/index.ts

@@ -0,0 +1,6 @@
+export * from './GetJavaScriptRenderMapVisitor';
+export * from './GetJavaScriptTypeManifestVisitor';
+export * from './GetJavaScriptValidatorBagVisitor';
+export * from './RenderJavaScriptValueNode';
+export * from './JavaScriptImportMap';
+export * from './RenderJavaScriptVisitor';

package/src/renderers/js/templates/accountsIndex.njk

@@ -0,0 +1,9 @@
+{% extends "layout.njk" %}
+
+{% block main %}
+{% for account in accountsToExport | sort(false, false, 'metadata.name') %}
+export * from './{{ account.name | camelCase }}';
+{% else %}
+export default {};
+{% endfor %}
+{% endblock %}

package/src/renderers/js/templates/accountsPage.njk

@@ -0,0 +1,122 @@
+{% extends "layout.njk" %}
+{% import "macros.njk" as macros %}
+
+{% block main %}
+{{ imports }}
+
+{{ macros.docblock(definedType.docs) }}
+export type {{ account.name | pascalCase }} = Account<{{ account.name | pascalCase }}AccountData>;
+
+{{ macros.exportType(account.name | pascalCase + 'AccountData', account.name | pascalCase + 'AccountArgs', typeManifest) }}
+
+export async function fetch{{ account.name | pascalCase }}(
+  context: Pick<Context, 'rpc' | 'serializer'>,
+  publicKey: PublicKey,
+  options?: RpcGetAccountOptions,
+): Promise<{{ account.name | pascalCase }}> {
+  const maybeAccount = await context.rpc.getAccount(publicKey, options);
+  assertAccountExists(maybeAccount, '{{ account.name | pascalCase }}');
+  return deserialize{{ account.name | pascalCase }}(context, maybeAccount);
+}
+
+export async function safeFetch{{ account.name | pascalCase }}(
+  context: Pick<Context, 'rpc' | 'serializer'>,
+  publicKey: PublicKey,
+  options?: RpcGetAccountOptions,
+): Promise<{{ account.name | pascalCase }} | null> {
+  const maybeAccount = await context.rpc.getAccount(publicKey, options);
+  return maybeAccount.exists
+    ? deserialize{{ account.name | pascalCase }}(context, maybeAccount)
+    : null;
+}
+
+export async function fetchAll{{ account.name | pascalCase }}(
+  context: Pick<Context, 'rpc' | 'serializer'>,
+  publicKeys: PublicKey[],
+  options?: RpcGetAccountsOptions,
+): Promise<{{ account.name | pascalCase }}[]> {
+  const maybeAccounts = await context.rpc.getAccounts(publicKeys, options);
+  return maybeAccounts.map((maybeAccount) => {
+    assertAccountExists(maybeAccount, '{{ account.name | pascalCase }}');
+    return deserialize{{ account.name | pascalCase }}(context, maybeAccount);
+  });
+}
+
+export async function safeFetchAll{{ account.name | pascalCase }}(
+  context: Pick<Context, 'rpc' | 'serializer'>,
+  publicKeys: PublicKey[],
+  options?: RpcGetAccountsOptions,
+): Promise<{{ account.name | pascalCase }}[]> {
+  const maybeAccounts = await context.rpc.getAccounts(publicKeys, options);
+  return maybeAccounts
+    .filter((maybeAccount) => maybeAccount.exists)
+    .map((maybeAccount) => deserialize{{ account.name | pascalCase }}(context, maybeAccount as RpcAccount));
+}
+
+export function get{{ account.name | pascalCase }}GpaBuilder(context: Pick<Context, 'rpc' | 'serializer' | 'programs'>) {
+  const s = context.serializer;
+  const programId = context.programs.get('{{ program.name | camelCase }}').publicKey;
+  return gpaBuilder(context, programId)
+    .registerFields<{{ gpaFields.type }}>({{ gpaFields.serializers }})
+    .deserializeUsing<{{ account.name | pascalCase }}>((account) => deserialize{{ account.name | pascalCase }}(context, account))
+    {%- if account.metadata.discriminator.kind === 'field' and discriminatorValue %}
+      .whereField('{{ account.metadata.discriminator.name }}', {{ discriminatorValue }})
+    {% elif account.metadata.discriminator.kind === 'size' and account.metadata.size %}
+      .whereSize({{ account.metadata.size }})
+    {% endif -%}
+  ;
+}
+
+export function deserialize{{ account.name | pascalCase }}(
+  context: Pick<Context, 'serializer'>,
+  rawAccount: RpcAccount,
+): {{ account.name | pascalCase }} {
+  return deserializeAccount(rawAccount, get{{ account.name | pascalCase }}AccountDataSerializer(context));
+}
+
+{{ macros.exportSerializer(account.name | pascalCase + 'AccountData', account.name | pascalCase + 'AccountArgs', typeManifest) }}
+
+{% if account.metadata.size !== null %}
+export function get{{ account.name | pascalCase }}Size(_context = {}): number {
+  return {{ account.metadata.size }};
+}
+{% else %}
+export function get{{ account.name | pascalCase }}Size(
+  context: Pick<Context, 'serializer'>
+): number | null {
+  return get{{ account.name | pascalCase }}AccountDataSerializer(context).fixedSize;
+}
+{% endif %}
+
+{% if seeds.length > 0 %}
+export function find{{ account.name | pascalCase }}Pda(
+  context: Pick<Context, 'eddsa' | 'programs'{% if account.hasVariableSeeds %} | 'serializer'{% endif %}>,
+  {% if account.hasVariableSeeds %}
+    seeds: {
+      {% for seed in seeds %}
+        {% if seed.kind === 'variable' %}
+          /** {{ seed.description }} */
+          {{ seed.name | camelCase }}: {{ seed.typeManifest.looseType }};
+        {% endif %}
+      {% endfor %}
+    }
+  {% endif %}
+): Pda {
+  {% if account.hasVariableSeeds %}
+    const s = context.serializer;
+  {% endif %}
+  const programId: PublicKey = context.programs.get('{{ program.metadata.name | camelCase }}').publicKey;
+  return context.eddsa.findPda(programId, [
+    {% for seed in seeds %}
+      {% if seed.kind === 'programId' %}
+        programId.bytes,
+      {% elif seed.kind === 'literal' %}
+        utf8.serialize("{{ seed.value }}"),
+      {% else %}
+        {{ seed.typeManifest.serializer }}.serialize(seeds.{{ seed.name | camelCase }}),
+      {% endif %}
+    {% endfor %}
+  ]);
+}
+{% endif %}
+{% endblock %}

package/src/renderers/js/templates/definedTypesIndex.njk

@@ -0,0 +1,9 @@
+{% extends "layout.njk" %}
+
+{% block main %}
+{% for definedType in definedTypesToExport | sort(false, false, 'metadata.name') %}
+export * from './{{ definedType.name | camelCase }}';
+{% else %}
+export default {};
+{% endfor %}
+{% endblock %}

package/src/renderers/js/templates/definedTypesPage.njk

@@ -0,0 +1,13 @@
+{% extends "layout.njk" %}
+{% import "macros.njk" as macros %}
+
+{% block main %}
+{{ imports }}
+
+{{ macros.docblock(definedType.docs) }}
+{{ macros.exportType(definedType.name | pascalCase, definedType.name | pascalCase + 'Args', typeManifest) }}
+
+{{ macros.exportSerializer(definedType.name | pascalCase, definedType.name | pascalCase + 'Args', typeManifest) }}
+
+{% include "definedTypesPageDataEnums.njk" %}
+{% endblock %}

package/src/renderers/js/templates/definedTypesPageDataEnums.njk

@@ -0,0 +1,26 @@
+{% if definedType.type.nodeClass === 'TypeEnumNode' and definedType.type.isDataEnum() %}
+  {% set strictName = definedType.name | pascalCase %}
+  {% set looseName = definedType.name | pascalCase + 'Args' if typeManifest.hasLooseType else strictName %}
+  // Data Enum Helpers.
+  {% for variant in definedType.type.variants %}
+    {% if variant.nodeClass === 'TypeEnumStructVariantNode' %}
+      export function {{ definedType.name | camelCase }}(kind: '{{ variant.name | pascalCase }}', data: GetDataEnumKindContent<{{ looseName }}, '{{ variant.name | pascalCase }}'>): GetDataEnumKind<{{ looseName }}, '{{ variant.name | pascalCase }}'>;
+    {% elif variant.nodeClass === 'TypeEnumTupleVariantNode' %}
+      export function {{ definedType.name | camelCase }}(kind: '{{ variant.name | pascalCase }}', data: GetDataEnumKindContent<{{ looseName }}, '{{ variant.name | pascalCase }}'>['fields']): GetDataEnumKind<{{ looseName }}, '{{ variant.name | pascalCase }}'>;
+    {% else %}
+      export function {{ definedType.name | camelCase }}(kind: '{{ variant.name | pascalCase }}'): GetDataEnumKind<{{ looseName }}, '{{ variant.name | pascalCase }}'>;
+    {% endif %}
+  {% endfor %}
+  export function {{ definedType.name | camelCase }}<K extends {{ looseName }}['__kind']>(
+    kind: K,
+    data?: any,
+  ): Extract<{{ looseName }}, { __kind: K }> {
+    return Array.isArray(data) ? { __kind: kind, fields: data } : { __kind: kind, ...(data ?? {}) };
+  }
+  export function is{{ strictName }}<K extends {{ strictName }}['__kind']>(
+    kind: K,
+    value: {{ strictName }},
+  ): value is {{ strictName }} & { __kind: K } {
+    return value.__kind === kind;
+  };
+{% endif %}

package/src/renderers/js/templates/errorsIndex.njk

@@ -0,0 +1,9 @@
+{% extends "layout.njk" %}
+
+{% block main %}
+{% for program in programsToExport | sort(false, false, 'metadata.name') %}
+export * from './{{ program.metadata.name | camelCase }}';
+{% else %}
+export default {};
+{% endfor %}
+{% endblock %}