@metaplex-foundation/kinobi 0.0.1

package/src/visitors/BaseNodeOrNullVisitor.ts

@@ -0,0 +1,202 @@
+import type { Visitor } from './Visitor';
+import * as nodes from '../nodes';
+
+export class BaseNodeOrNullVisitor implements Visitor<nodes.Node | null> {
+  visitRoot(root: nodes.RootNode): nodes.Node | null {
+    return new nodes.RootNode(
+      root.programs
+        .map((program) => program.accept(this))
+        .filter(nodes.removeNullAndAssertNodeFilter(nodes.assertProgramNode))
+    );
+  }
+
+  visitProgram(program: nodes.ProgramNode): nodes.Node | null {
+    return new nodes.ProgramNode(
+      program.metadata,
+      program.accounts
+        .map((account) => account.accept(this))
+        .filter(nodes.removeNullAndAssertNodeFilter(nodes.assertAccountNode)),
+      program.instructions
+        .map((instruction) => instruction.accept(this))
+        .filter(
+          nodes.removeNullAndAssertNodeFilter(nodes.assertInstructionNode)
+        ),
+      program.definedTypes
+        .map((type) => type.accept(this))
+        .filter(
+          nodes.removeNullAndAssertNodeFilter(nodes.assertDefinedTypeNode)
+        ),
+      program.errors
+        .map((error) => error.accept(this))
+        .filter(nodes.removeNullAndAssertNodeFilter(nodes.assertErrorNode))
+    );
+  }
+
+  visitAccount(account: nodes.AccountNode): nodes.Node | null {
+    const accountType = account.type.accept(this);
+    if (accountType === null) return null;
+    nodes.assertTypeStructNode(accountType);
+    return new nodes.AccountNode(account.metadata, accountType);
+  }
+
+  visitInstruction(instruction: nodes.InstructionNode): nodes.Node | null {
+    const args = instruction.args.accept(this);
+    if (args === null) return null;
+    nodes.assertTypeStructNode(args);
+    return new nodes.InstructionNode(
+      instruction.metadata,
+      instruction.accounts,
+      args,
+      instruction.subInstructions
+        .map((ix) => ix.accept(this))
+        .filter(
+          nodes.removeNullAndAssertNodeFilter(nodes.assertInstructionNode)
+        )
+    );
+  }
+
+  visitDefinedType(definedType: nodes.DefinedTypeNode): nodes.Node | null {
+    const type = definedType.type.accept(this);
+    if (type === null) return null;
+    nodes.assertTypeStructOrEnumNode(type);
+    return new nodes.DefinedTypeNode(definedType.metadata, type);
+  }
+
+  visitError(error: nodes.ErrorNode): nodes.Node | null {
+    return error;
+  }
+
+  visitTypeArray(typeArray: nodes.TypeArrayNode): nodes.Node | null {
+    const type = typeArray.itemType.accept(this);
+    if (type === null) return null;
+    nodes.assertTypeNode(type);
+    return new nodes.TypeArrayNode(type, typeArray.size);
+  }
+
+  visitTypeDefinedLink(
+    typeDefinedLink: nodes.TypeDefinedLinkNode
+  ): nodes.Node | null {
+    return typeDefinedLink;
+  }
+
+  visitTypeEnum(typeEnum: nodes.TypeEnumNode): nodes.Node | null {
+    const variants = typeEnum.variants
+      .map((variant): nodes.TypeEnumVariantNode | null => {
+        const newVariant = variant.accept(this);
+        if (newVariant === null) return null;
+        nodes.assertTypeEnumVariantNode(newVariant);
+        return newVariant;
+      })
+      .filter((v): v is nodes.TypeEnumVariantNode => v !== null);
+
+    return new nodes.TypeEnumNode(typeEnum.name, variants);
+  }
+
+  visitTypeEnumEmptyVariant(
+    typeEnumEmptyVariant: nodes.TypeEnumEmptyVariantNode
+  ): nodes.Node | null {
+    return typeEnumEmptyVariant;
+  }
+
+  visitTypeEnumStructVariant(
+    typeEnumStructVariant: nodes.TypeEnumStructVariantNode
+  ): nodes.Node | null {
+    const newStruct = typeEnumStructVariant.struct.accept(this);
+    if (!newStruct) return null;
+    nodes.assertTypeStructNode(newStruct);
+    return new nodes.TypeEnumStructVariantNode(
+      typeEnumStructVariant.name,
+      newStruct
+    );
+  }
+
+  visitTypeEnumTupleVariant(
+    typeEnumTupleVariant: nodes.TypeEnumTupleVariantNode
+  ): nodes.Node | null {
+    const newTuple = typeEnumTupleVariant.tuple.accept(this);
+    if (!newTuple) return null;
+    nodes.assertTypeTupleNode(newTuple);
+    return new nodes.TypeEnumTupleVariantNode(
+      typeEnumTupleVariant.name,
+      newTuple
+    );
+  }
+
+  visitTypeLeaf(typeLeaf: nodes.TypeLeafNode): nodes.Node | null {
+    return typeLeaf;
+  }
+
+  visitTypeLeafWrapper(
+    typeLeafWrapper: nodes.TypeLeafWrapperNode
+  ): nodes.Node | null {
+    const leaf = typeLeafWrapper.leaf.accept(this);
+    if (leaf === null) return null;
+    nodes.assertTypeLeafNode(leaf);
+    return new nodes.TypeLeafWrapperNode(typeLeafWrapper.wrapper, leaf);
+  }
+
+  visitTypeMap(typeMap: nodes.TypeMapNode): nodes.Node | null {
+    const keyType = typeMap.keyType.accept(this);
+    const valueType = typeMap.valueType.accept(this);
+    if (keyType === null || valueType === null) return null;
+    nodes.assertTypeNode(keyType);
+    nodes.assertTypeNode(valueType);
+    return new nodes.TypeMapNode(typeMap.mapType, keyType, valueType);
+  }
+
+  visitTypeOption(typeOption: nodes.TypeOptionNode): nodes.Node | null {
+    const type = typeOption.type.accept(this);
+    if (type === null) return null;
+    nodes.assertTypeNode(type);
+    return new nodes.TypeOptionNode(typeOption.optionType, type);
+  }
+
+  visitTypeSet(typeSet: nodes.TypeSetNode): nodes.Node | null {
+    const type = typeSet.type.accept(this);
+    if (type === null) return null;
+    nodes.assertTypeNode(type);
+    return new nodes.TypeSetNode(typeSet.setType, type);
+  }
+
+  visitTypeStruct(typeStruct: nodes.TypeStructNode): nodes.Node | null {
+    const fields = typeStruct.fields
+      .map((field): nodes.TypeStructFieldNode | null => {
+        const newField = field.accept(this);
+        if (newField === null) return null;
+        nodes.assertTypeStructFieldNode(newField);
+        return newField;
+      })
+      .filter((field): field is nodes.TypeStructFieldNode => field !== null);
+
+    return new nodes.TypeStructNode(typeStruct.name, fields);
+  }
+
+  visitTypeStructField(
+    typeStructField: nodes.TypeStructFieldNode
+  ): nodes.Node | null {
+    const newType = typeStructField.type.accept(this);
+    if (newType === null) return null;
+    nodes.assertTypeNode(newType);
+    return new nodes.TypeStructFieldNode(typeStructField.metadata, newType);
+  }
+
+  visitTypeTuple(typeTuple: nodes.TypeTupleNode): nodes.Node | null {
+    const items = typeTuple.itemTypes
+      .map((type) => {
+        const newType = type.accept(this);
+        if (newType === null) return null;
+        nodes.assertTypeNode(newType);
+        return newType;
+      })
+      .filter((type): type is nodes.TypeNode => type !== null);
+
+    return new nodes.TypeTupleNode(items);
+  }
+
+  visitTypeVec(typeVec: nodes.TypeVecNode): nodes.Node | null {
+    const type = typeVec.itemType.accept(this);
+    if (type === null) return null;
+    nodes.assertTypeNode(type);
+    return new nodes.TypeVecNode(type);
+  }
+}

package/src/visitors/BaseNodeVisitor.ts

@@ -0,0 +1,173 @@
+import type { Visitor } from './Visitor';
+import * as nodes from '../nodes';
+
+export class BaseNodeVisitor implements Visitor<nodes.Node> {
+  visitRoot(root: nodes.RootNode): nodes.Node {
+    return new nodes.RootNode(
+      root.programs
+        .map((program) => program.accept(this))
+        .filter(nodes.assertNodeFilter(nodes.assertProgramNode))
+    );
+  }
+
+  visitProgram(program: nodes.ProgramNode): nodes.Node {
+    return new nodes.ProgramNode(
+      program.metadata,
+      program.accounts
+        .map((account) => account.accept(this))
+        .filter(nodes.assertNodeFilter(nodes.assertAccountNode)),
+      program.instructions
+        .map((instruction) => instruction.accept(this))
+        .filter(nodes.assertNodeFilter(nodes.assertInstructionNode)),
+      program.definedTypes
+        .map((type) => type.accept(this))
+        .filter(nodes.assertNodeFilter(nodes.assertDefinedTypeNode)),
+      program.errors
+        .map((error) => error.accept(this))
+        .filter(nodes.assertNodeFilter(nodes.assertErrorNode))
+    );
+  }
+
+  visitAccount(account: nodes.AccountNode): nodes.Node {
+    const accountType = account.type.accept(this);
+    nodes.assertTypeStructNode(accountType);
+    return new nodes.AccountNode(account.metadata, accountType);
+  }
+
+  visitInstruction(instruction: nodes.InstructionNode): nodes.Node {
+    const args = instruction.args.accept(this);
+    nodes.assertTypeStructNode(args);
+    return new nodes.InstructionNode(
+      instruction.metadata,
+      instruction.accounts,
+      args,
+      instruction.subInstructions
+        .map((ix) => ix.accept(this))
+        .filter(
+          nodes.removeNullAndAssertNodeFilter(nodes.assertInstructionNode)
+        )
+    );
+  }
+
+  visitDefinedType(definedType: nodes.DefinedTypeNode): nodes.Node {
+    const type = definedType.type.accept(this);
+    nodes.assertTypeStructOrEnumNode(type);
+    return new nodes.DefinedTypeNode(definedType.metadata, type);
+  }
+
+  visitError(error: nodes.ErrorNode): nodes.Node {
+    return error;
+  }
+
+  visitTypeArray(typeArray: nodes.TypeArrayNode): nodes.Node {
+    const type = typeArray.itemType.accept(this);
+    nodes.assertTypeNode(type);
+    return new nodes.TypeArrayNode(type, typeArray.size);
+  }
+
+  visitTypeDefinedLink(typeDefinedLink: nodes.TypeDefinedLinkNode): nodes.Node {
+    return typeDefinedLink;
+  }
+
+  visitTypeEnum(typeEnum: nodes.TypeEnumNode): nodes.Node {
+    return new nodes.TypeEnumNode(
+      typeEnum.name,
+      typeEnum.variants.map((variant) => {
+        const newVariant = variant.accept(this);
+        nodes.assertTypeEnumVariantNode(newVariant);
+        return newVariant;
+      })
+    );
+  }
+
+  visitTypeEnumEmptyVariant(
+    typeEnumEmptyVariant: nodes.TypeEnumEmptyVariantNode
+  ): nodes.Node {
+    return typeEnumEmptyVariant;
+  }
+
+  visitTypeEnumStructVariant(
+    typeEnumStructVariant: nodes.TypeEnumStructVariantNode
+  ): nodes.Node {
+    const newStruct = typeEnumStructVariant.struct.accept(this);
+    nodes.assertTypeStructNode(newStruct);
+    return new nodes.TypeEnumStructVariantNode(
+      typeEnumStructVariant.name,
+      newStruct
+    );
+  }
+
+  visitTypeEnumTupleVariant(
+    typeEnumTupleVariant: nodes.TypeEnumTupleVariantNode
+  ): nodes.Node {
+    const newTuple = typeEnumTupleVariant.tuple.accept(this);
+    nodes.assertTypeTupleNode(newTuple);
+    return new nodes.TypeEnumTupleVariantNode(
+      typeEnumTupleVariant.name,
+      newTuple
+    );
+  }
+
+  visitTypeLeaf(typeLeaf: nodes.TypeLeafNode): nodes.Node {
+    return typeLeaf;
+  }
+
+  visitTypeLeafWrapper(typeLeafWrapper: nodes.TypeLeafWrapperNode): nodes.Node {
+    const leaf = typeLeafWrapper.leaf.accept(this);
+    nodes.assertTypeLeafNode(leaf);
+    return new nodes.TypeLeafWrapperNode(typeLeafWrapper.wrapper, leaf);
+  }
+
+  visitTypeMap(typeMap: nodes.TypeMapNode): nodes.Node {
+    const keyType = typeMap.keyType.accept(this);
+    nodes.assertTypeNode(keyType);
+    const valueType = typeMap.valueType.accept(this);
+    nodes.assertTypeNode(valueType);
+    return new nodes.TypeMapNode(typeMap.mapType, keyType, valueType);
+  }
+
+  visitTypeOption(typeOption: nodes.TypeOptionNode): nodes.Node {
+    const type = typeOption.type.accept(this);
+    nodes.assertTypeNode(type);
+    return new nodes.TypeOptionNode(typeOption.optionType, type);
+  }
+
+  visitTypeSet(typeSet: nodes.TypeSetNode): nodes.Node {
+    const type = typeSet.type.accept(this);
+    nodes.assertTypeNode(type);
+    return new nodes.TypeSetNode(typeSet.setType, type);
+  }
+
+  visitTypeStruct(typeStruct: nodes.TypeStructNode): nodes.Node {
+    return new nodes.TypeStructNode(
+      typeStruct.name,
+      typeStruct.fields.map((field): nodes.TypeStructFieldNode => {
+        const newField = field.accept(this);
+        nodes.assertTypeStructFieldNode(newField);
+        return newField;
+      })
+    );
+  }
+
+  visitTypeStructField(typeStructField: nodes.TypeStructFieldNode): nodes.Node {
+    const newType = typeStructField.type.accept(this);
+    nodes.assertTypeNode(newType);
+    return new nodes.TypeStructFieldNode(typeStructField.metadata, newType);
+  }
+
+  visitTypeTuple(typeTuple: nodes.TypeTupleNode): nodes.Node {
+    return new nodes.TypeTupleNode(
+      typeTuple.itemTypes.map((type) => {
+        const newType = type.accept(this);
+        nodes.assertTypeNode(newType);
+        return newType;
+      })
+    );
+  }
+
+  visitTypeVec(typeVec: nodes.TypeVecNode): nodes.Node {
+    const type = typeVec.itemType.accept(this);
+    nodes.assertTypeNode(type);
+    return new nodes.TypeVecNode(type);
+  }
+}

package/src/visitors/BaseThrowVisitor.ts

@@ -0,0 +1,101 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import * as nodes from '../nodes';
+import type { Visitor } from './Visitor';
+
+export class BaseThrowVisitor<T> implements Visitor<T> {
+  visitRoot(root: nodes.RootNode): T {
+    throw new Error('This visitor does not support Root nodes.');
+  }
+
+  visitProgram(program: nodes.ProgramNode): T {
+    throw new Error('This visitor does not support Program nodes.');
+  }
+
+  visitAccount(account: nodes.AccountNode): T {
+    throw new Error('This visitor does not support Account nodes.');
+  }
+
+  visitInstruction(instruction: nodes.InstructionNode): T {
+    throw new Error('This visitor does not support Instruction nodes.');
+  }
+
+  visitDefinedType(definedType: nodes.DefinedTypeNode): T {
+    throw new Error('This visitor does not support DefinedType nodes.');
+  }
+
+  visitError(error: nodes.ErrorNode): T {
+    throw new Error('This visitor does not support Error nodes.');
+  }
+
+  visitTypeArray(typeArray: nodes.TypeArrayNode): T {
+    throw new Error('This visitor does not support TypeArray nodes.');
+  }
+
+  visitTypeDefinedLink(typeDefinedLink: nodes.TypeDefinedLinkNode): T {
+    throw new Error('This visitor does not support TypeDefinedLink nodes.');
+  }
+
+  visitTypeEnum(typeEnum: nodes.TypeEnumNode): T {
+    throw new Error('This visitor does not support TypeEnum nodes.');
+  }
+
+  visitTypeEnumEmptyVariant(
+    typeEnumEmptyVariant: nodes.TypeEnumEmptyVariantNode
+  ): T {
+    throw new Error(
+      'This visitor does not support TypeEnumEmptyVariant nodes.'
+    );
+  }
+
+  visitTypeEnumStructVariant(
+    typeEnumStructVariant: nodes.TypeEnumStructVariantNode
+  ): T {
+    throw new Error(
+      'This visitor does not support TypeEnumStructVariant nodes.'
+    );
+  }
+
+  visitTypeEnumTupleVariant(
+    typeEnumTupleVariant: nodes.TypeEnumTupleVariantNode
+  ): T {
+    throw new Error(
+      'This visitor does not support TypeEnumTupleVariant nodes.'
+    );
+  }
+
+  visitTypeLeaf(typeLeaf: nodes.TypeLeafNode): T {
+    throw new Error('This visitor does not support TypeLeaf nodes.');
+  }
+
+  visitTypeLeafWrapper(typeLeafWrapper: nodes.TypeLeafWrapperNode): T {
+    throw new Error('This visitor does not support TypeLeafWrapper nodes.');
+  }
+
+  visitTypeMap(typeMap: nodes.TypeMapNode): T {
+    throw new Error('This visitor does not support TypeMap nodes.');
+  }
+
+  visitTypeOption(typeOption: nodes.TypeOptionNode): T {
+    throw new Error('This visitor does not support TypeOption nodes.');
+  }
+
+  visitTypeSet(typeSet: nodes.TypeSetNode): T {
+    throw new Error('This visitor does not support TypeSet nodes.');
+  }
+
+  visitTypeStruct(typeStruct: nodes.TypeStructNode): T {
+    throw new Error('This visitor does not support TypeStruct nodes.');
+  }
+
+  visitTypeStructField(typeStructField: nodes.TypeStructFieldNode): T {
+    throw new Error('This visitor does not support TypeStructField nodes.');
+  }
+
+  visitTypeTuple(typeTuple: nodes.TypeTupleNode): T {
+    throw new Error('This visitor does not support TypeTuple nodes.');
+  }
+
+  visitTypeVec(typeVec: nodes.TypeVecNode): T {
+    throw new Error('This visitor does not support TypeVec nodes.');
+  }
+}

package/src/visitors/BaseVoidVisitor.ts

@@ -0,0 +1,104 @@
+import * as nodes from '../nodes';
+import type { Visitor } from './Visitor';
+
+export abstract class BaseVoidVisitor implements Visitor<void> {
+  visitRoot(root: nodes.RootNode): void {
+    root.programs.forEach((program) => program.accept(this));
+  }
+
+  visitProgram(program: nodes.ProgramNode): void {
+    program.accounts.forEach((account) => account.accept(this));
+    program.instructions.forEach((instruction) => instruction.accept(this));
+    program.definedTypes.forEach((type) => type.accept(this));
+    program.errors.forEach((type) => type.accept(this));
+  }
+
+  visitAccount(account: nodes.AccountNode): void {
+    account.type.accept(this);
+    account.variableSeeds.forEach((seed) => seed.type.accept(this));
+  }
+
+  visitInstruction(instruction: nodes.InstructionNode): void {
+    instruction.args.accept(this);
+    instruction.subInstructions.forEach((ix) => ix.accept(this));
+  }
+
+  visitDefinedType(definedType: nodes.DefinedTypeNode): void {
+    definedType.type.accept(this);
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  visitError(error: nodes.ErrorNode): void {
+    //
+  }
+
+  visitTypeArray(typeArray: nodes.TypeArrayNode): void {
+    typeArray.itemType.accept(this);
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  visitTypeDefinedLink(typeDefinedLink: nodes.TypeDefinedLinkNode): void {
+    //
+  }
+
+  visitTypeEnum(typeEnum: nodes.TypeEnumNode): void {
+    typeEnum.variants.forEach((variant) => variant.accept(this));
+  }
+
+  visitTypeEnumEmptyVariant(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    typeEnumEmptyVariant: nodes.TypeEnumEmptyVariantNode
+  ): void {
+    //
+  }
+
+  visitTypeEnumStructVariant(
+    typeEnumStructVariant: nodes.TypeEnumStructVariantNode
+  ): void {
+    typeEnumStructVariant.struct.accept(this);
+  }
+
+  visitTypeEnumTupleVariant(
+    typeEnumTupleVariant: nodes.TypeEnumTupleVariantNode
+  ): void {
+    typeEnumTupleVariant.tuple.accept(this);
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  visitTypeLeaf(typeLeaf: nodes.TypeLeafNode): void {
+    //
+  }
+
+  visitTypeLeafWrapper(typeLeafWrapper: nodes.TypeLeafWrapperNode): void {
+    typeLeafWrapper.leaf.accept(this);
+  }
+
+  visitTypeMap(typeMap: nodes.TypeMapNode): void {
+    typeMap.keyType.accept(this);
+    typeMap.valueType.accept(this);
+  }
+
+  visitTypeOption(typeOption: nodes.TypeOptionNode): void {
+    typeOption.type.accept(this);
+  }
+
+  visitTypeSet(typeSet: nodes.TypeSetNode): void {
+    typeSet.type.accept(this);
+  }
+
+  visitTypeStruct(typeStruct: nodes.TypeStructNode): void {
+    typeStruct.fields.forEach((field) => field.accept(this));
+  }
+
+  visitTypeStructField(typeStructField: nodes.TypeStructFieldNode): void {
+    typeStructField.type.accept(this);
+  }
+
+  visitTypeTuple(typeTuple: nodes.TypeTupleNode): void {
+    typeTuple.itemTypes.forEach((itemType) => itemType.accept(this));
+  }
+
+  visitTypeVec(typeVec: nodes.TypeVecNode): void {
+    typeVec.itemType.accept(this);
+  }
+}

package/src/visitors/DefaultVisitor.ts

@@ -0,0 +1,45 @@
+import * as nodes from '../nodes';
+import { BaseThrowVisitor } from './BaseThrowVisitor';
+import {
+  AutoSetAnchorDiscriminatorsVisitor,
+  AutoSetFixedAccountSizesVisitor,
+  DeduplicateIdenticalDefinedTypesVisitor,
+  DEFAULT_INSTRUCTION_ACCOUNT_DEFAULT_RULES,
+  SetInstructionAccountDefaultValuesVisitor,
+  TransformU8ArraysToBytesVisitor,
+  UnwrapInstructionArgsDefinedTypesVisitor,
+  UnwrapInstructionArgsStructVisitor,
+} from './transformers';
+import { Visitor } from './Visitor';
+
+export class DefaultVisitor extends BaseThrowVisitor<nodes.RootNode> {
+  visitRoot(currentRoot: nodes.RootNode): nodes.RootNode {
+    let root: nodes.Node = currentRoot;
+    const updateRoot = (visitor: Visitor<nodes.Node | null>) => {
+      const newRoot = root.accept(visitor);
+      nodes.assertRootNode(newRoot);
+      root = newRoot;
+    };
+
+    // Defined types.
+    updateRoot(new DeduplicateIdenticalDefinedTypesVisitor());
+
+    // Accounts.
+    updateRoot(new AutoSetFixedAccountSizesVisitor());
+
+    // Instructions.
+    updateRoot(new AutoSetAnchorDiscriminatorsVisitor());
+    updateRoot(
+      new SetInstructionAccountDefaultValuesVisitor(
+        DEFAULT_INSTRUCTION_ACCOUNT_DEFAULT_RULES
+      )
+    );
+    updateRoot(new UnwrapInstructionArgsDefinedTypesVisitor());
+    updateRoot(new UnwrapInstructionArgsStructVisitor());
+
+    // Extras.
+    updateRoot(new TransformU8ArraysToBytesVisitor());
+
+    return root;
+  }
+}

package/src/visitors/Dependency.ts

@@ -0,0 +1,23 @@
+/**
+ * Tells Kinobi where a dependency is located.
+ * This could be a recognized dependency, or any other string
+ * as long as renderers know how to map them into real libraries.
+ */
+export type Dependency =
+  | RelativeDependecy
+  | 'core'
+  | 'mplEssentials'
+  | 'mplDigitalAsset'
+  | string;
+
+/**
+ * Tells Kinobi where a local dependency is located.
+ * - `generated` means the dependency is located in the `generated` folder.
+ * - `root` means the dependency is located in the source folder, outside of the `generated` folder.
+ * - `rootHooked` means the dependency is located outside of the `generated` folder, in a
+ *    special folder that is used internally by the auto-generated code.
+ *
+ * These can be interpreted by renderers as they see fit as different languages
+ * have different ways of importing local files.
+ */
+export type RelativeDependecy = 'generated' | 'root' | 'rootHooked';