@seed-design/figma 0.0.5 → 0.0.15

package/src/codegen/targets/react/props.ts

@@ -0,0 +1,361 @@
+import {
+  createPropsTransformer,
+  definePropsTransformer,
+  type PropsTransformer,
+  type ValueTransformer,
+} from "@/codegen/core";
+import type { StyleService } from "@/entities";
+import type {
+  NormalizedCornerTrait,
+  NormalizedHasChildrenTrait,
+  NormalizedHasFramePropertiesTrait,
+  NormalizedHasGeometryTrait,
+  NormalizedHasLayoutTrait,
+  NormalizedIsLayerTrait,
+  NormalizedTypePropertiesTrait,
+} from "@/normalizer";
+import { match } from "ts-pattern";
+
+export interface PropsTransformers {
+  containerLayout: PropsTransformer<ContainerLayoutTrait, ContainerLayoutProps>;
+  selfLayout: PropsTransformer<SelfLayoutTrait, SelfLayoutProps>;
+  iconSelfLayout: PropsTransformer<SelfLayoutTrait, IconSelfLayoutProps>;
+  radius: PropsTransformer<RadiusTrait, RadiusProps>;
+  frameFill: PropsTransformer<FillTrait, FrameFillProps>;
+  shapeFill: PropsTransformer<FillTrait, ShapeFillProps>;
+  textFill: PropsTransformer<FillTrait, TextFillProps>;
+  stroke: PropsTransformer<StrokeTrait, StrokeProps>;
+  typeStyle: PropsTransformer<TypeStyleTrait, TypeStyleProps>;
+}
+
+export type ContainerLayoutTrait = NormalizedHasFramePropertiesTrait &
+  NormalizedHasChildrenTrait &
+  NormalizedHasLayoutTrait &
+  NormalizedIsLayerTrait;
+
+export type SelfLayoutTrait = NormalizedIsLayerTrait & NormalizedHasLayoutTrait;
+
+export type RadiusTrait = NormalizedCornerTrait & NormalizedIsLayerTrait;
+
+export type FillTrait = NormalizedIsLayerTrait & NormalizedHasGeometryTrait;
+
+export type StrokeTrait = NormalizedIsLayerTrait & NormalizedHasGeometryTrait;
+
+export type TypeStyleTrait = NormalizedTypePropertiesTrait & NormalizedIsLayerTrait;
+
+export interface ContainerLayoutProps {
+  direction?: "row" | "column";
+  justify?: "flex-start" | "center" | "flex-end" | "space-between";
+  align?: "stretch" | "flex-start" | "center" | "flex-end" | "baseline";
+  wrap?: "wrap" | "nowrap" | true;
+  gap?: string | 0;
+  pb?: string | 0;
+  pl?: string | 0;
+  pr?: string | 0;
+  pt?: string | 0;
+  px?: string | 0;
+  py?: string | 0;
+  p?: string | 0;
+}
+
+type ReactValueTransformer = ValueTransformer<string, string, string, number>;
+
+export function createContainerLayoutPropsTransformer(
+  valueTransformer: ReactValueTransformer,
+): PropsTransformer<ContainerLayoutTrait, ContainerLayoutProps> {
+  return createPropsTransformer({
+    _types: {
+      trait: {} as ContainerLayoutTrait,
+      props: {} as ContainerLayoutProps,
+    },
+    handlers: {
+      direction: ({ layoutMode }) =>
+        match(layoutMode)
+          .with("HORIZONTAL", () => "row" as const)
+          .with("VERTICAL", () => "column" as const)
+          .with("NONE", () => undefined)
+          .with(undefined, () => undefined)
+          .exhaustive(),
+      justify: ({ primaryAxisAlignItems }) =>
+        match(primaryAxisAlignItems)
+          .with("MIN", () => "flex-start" as const)
+          .with("CENTER", () => "center" as const)
+          .with("MAX", () => "flex-end" as const)
+          .with("SPACE_BETWEEN", () => "space-between" as const)
+          .with(undefined, () => undefined)
+          .exhaustive(),
+      align: ({ counterAxisAlignItems, children }) => {
+        const isStretch = children.every((child) => {
+          if (!("layoutAlign" in child)) {
+            return false;
+          }
+
+          return child.layoutAlign === "STRETCH";
+        });
+
+        if (isStretch) {
+          return "stretch";
+        }
+
+        return match(counterAxisAlignItems)
+          .with("MIN", () => "flex-start" as const)
+          .with("CENTER", () => "center" as const)
+          .with("MAX", () => "flex-end" as const)
+          .with("BASELINE", () => "baseline" as const)
+          .with(undefined, () => undefined)
+          .exhaustive();
+      },
+      wrap: ({ layoutWrap }) =>
+        match(layoutWrap)
+          .with("WRAP", () => true as const)
+          .with("NO_WRAP", () => "nowrap" as const)
+          .with(undefined, () => undefined)
+          .exhaustive(),
+      gap: (node) => {
+        if (node.children.length <= 1) {
+          return undefined;
+        }
+
+        if (node.primaryAxisAlignItems === "SPACE_BETWEEN") {
+          return undefined;
+        }
+
+        return valueTransformer.getFormattedValue.itemSpacing(node);
+      },
+      pt: (node) => valueTransformer.getFormattedValue.paddingTop(node),
+      pb: (node) => valueTransformer.getFormattedValue.paddingBottom(node),
+      pl: (node) => valueTransformer.getFormattedValue.paddingLeft(node),
+      pr: (node) => valueTransformer.getFormattedValue.paddingRight(node),
+    },
+    shorthands: {
+      p: ["pt", "pb", "pl", "pr"],
+      px: ["pl", "pr"],
+      py: ["pt", "pb"],
+    },
+    defaults: {
+      justify: "flex-start",
+      align: "stretch",
+      wrap: "nowrap",
+      gap: 0,
+      p: 0,
+      px: 0,
+      py: 0,
+      pb: 0,
+      pl: 0,
+      pr: 0,
+      pt: 0,
+    },
+  });
+}
+
+export interface SelfLayoutProps {
+  grow?: 0 | 1 | true;
+  alignSelf?: "stretch";
+  width?: string | number;
+  height?: string | number;
+  minWidth?: string | number;
+  minHeight?: string | number;
+  maxWidth?: string | number;
+  maxHeight?: string | number;
+}
+
+export function createSelfLayoutPropsTransformer(
+  valueTransformer: ReactValueTransformer,
+): PropsTransformer<SelfLayoutTrait, SelfLayoutProps> {
+  return createPropsTransformer({
+    _types: {
+      trait: {} as SelfLayoutTrait,
+      props: {} as SelfLayoutProps,
+    },
+    handlers: {
+      grow: ({ layoutGrow }) => (layoutGrow === 1 ? true : layoutGrow),
+      alignSelf: ({ layoutAlign }) =>
+        match(layoutAlign)
+          .with("STRETCH", () => "stretch" as const)
+          .with("INHERIT", () => undefined)
+          .with("MIN", () => undefined) // Deprecated in Figma
+          .with("CENTER", () => undefined) // Deprecated in Figma
+          .with("MAX", () => undefined) // Deprecated in Figma
+          .with(undefined, () => undefined)
+          .exhaustive(),
+      height: (node) =>
+        node.layoutSizingVertical === "FIXED"
+          ? valueTransformer.getFormattedValue.height(node)
+          : undefined,
+      width: (node) =>
+        node.layoutSizingHorizontal === "FIXED"
+          ? valueTransformer.getFormattedValue.width(node)
+          : undefined,
+      minHeight: (node) =>
+        node.layoutSizingVertical === "HUG"
+          ? valueTransformer.getFormattedValue.minHeight(node)
+          : undefined,
+      maxHeight: (node) =>
+        node.layoutSizingVertical === "HUG"
+          ? valueTransformer.getFormattedValue.maxHeight(node)
+          : undefined,
+      minWidth: (node) =>
+        node.layoutSizingHorizontal === "HUG"
+          ? valueTransformer.getFormattedValue.minWidth(node)
+          : undefined,
+      maxWidth: (node) =>
+        node.layoutSizingHorizontal === "HUG"
+          ? valueTransformer.getFormattedValue.maxWidth(node)
+          : undefined,
+    },
+    defaults: {
+      grow: 0,
+    },
+  });
+}
+
+export interface IconSelfLayoutProps {
+  size?: string | number;
+}
+
+export function createIconSelfLayoutPropsTransformer(valueTransformer: ReactValueTransformer) {
+  return createPropsTransformer({
+    _types: {
+      trait: {} as SelfLayoutTrait,
+      props: {} as IconSelfLayoutProps,
+    },
+    handlers: {
+      size: (node) => valueTransformer.getFormattedValue.width(node),
+    },
+  });
+}
+
+export interface RadiusProps {
+  borderRadius?: string | 0;
+  borderTopLeftRadius?: string | 0;
+  borderTopRightRadius?: string | 0;
+  borderBottomLeftRadius?: string | 0;
+  borderBottomRightRadius?: string | 0;
+}
+
+export function createRadiusPropsTransformer(valueTransformer: ReactValueTransformer) {
+  return createPropsTransformer({
+    _types: {
+      trait: {} as RadiusTrait,
+      props: {} as RadiusProps,
+    },
+    handlers: {
+      borderTopLeftRadius: (node) => valueTransformer.getFormattedValue.topLeftRadius(node),
+      borderTopRightRadius: (node) => valueTransformer.getFormattedValue.topRightRadius(node),
+      borderBottomLeftRadius: (node) => valueTransformer.getFormattedValue.bottomLeftRadius(node),
+      borderBottomRightRadius: (node) => valueTransformer.getFormattedValue.bottomRightRadius(node),
+    },
+    shorthands: {
+      borderRadius: [
+        "borderTopLeftRadius",
+        "borderTopRightRadius",
+        "borderBottomLeftRadius",
+        "borderBottomRightRadius",
+      ],
+    },
+    defaults: {
+      borderRadius: 0,
+      borderTopLeftRadius: 0,
+      borderTopRightRadius: 0,
+      borderBottomLeftRadius: 0,
+      borderBottomRightRadius: 0,
+    },
+  });
+}
+
+export interface TypeStyleProps {
+  textStyle?: string;
+  fontSize?: string;
+  fontWeight?: string | number;
+  lineHeight?: string;
+  maxLines?: number;
+}
+
+export function createTypeStylePropsTransformer({
+  valueTransformer,
+  styleService,
+}: {
+  valueTransformer: ReactValueTransformer;
+  styleService: StyleService;
+}): PropsTransformer<TypeStyleTrait, TypeStyleProps> {
+  return definePropsTransformer((node) => {
+    const styleName = node.textStyleKey ? styleService.getStyleName(node.textStyleKey) : undefined;
+    const maxLines =
+      node.style.textTruncation === "ENDING" ? (node.style.maxLines ?? undefined) : undefined;
+
+    if (styleName) {
+      return {
+        textStyle: styleName,
+        maxLines,
+      };
+    }
+
+    return {
+      fontSize: valueTransformer.getFormattedValue.fontSize(node),
+      fontWeight: valueTransformer.getFormattedValue.fontWeight(node),
+      lineHeight: valueTransformer.getFormattedValue.lineHeight(node),
+      maxLines,
+    };
+  });
+}
+
+export interface FrameFillProps {
+  bg?: string;
+}
+
+export function createFrameFillPropsTransformer(valueTransformer: ReactValueTransformer) {
+  return definePropsTransformer<FillTrait, FrameFillProps>((node) => {
+    const bg = valueTransformer.getFormattedValue.frameFill(node);
+
+    return {
+      bg,
+    };
+  });
+}
+
+export interface ShapeFillProps {
+  color?: string;
+}
+
+export function createShapeFillPropsTransformer(valueTransformer: ReactValueTransformer) {
+  return definePropsTransformer<FillTrait, ShapeFillProps>((node) => {
+    const color = valueTransformer.getFormattedValue.shapeFill(node);
+
+    return {
+      color,
+    };
+  });
+}
+
+export interface TextFillProps {
+  color?: string;
+}
+
+export function createTextFillPropsTransformer(valueTransformer: ReactValueTransformer) {
+  return definePropsTransformer<FillTrait, TextFillProps>((node) => {
+    const color = valueTransformer.getFormattedValue.textFill(node);
+
+    return {
+      color,
+    };
+  });
+}
+
+export interface StrokeProps {
+  borderWidth?: number;
+  borderColor?: string;
+}
+
+export function createStrokePropsTransformer(
+  valueTransformer: ReactValueTransformer,
+): PropsTransformer<StrokeTrait, StrokeProps> {
+  return definePropsTransformer((node) => {
+    const borderColor = valueTransformer.getFormattedValue.stroke(node);
+    const borderWidth = borderColor ? node.strokeWeight : undefined;
+
+    return {
+      borderColor,
+      borderWidth,
+    };
+  });
+}

package/src/codegen/targets/react/shape.ts

@@ -0,0 +1,36 @@
+import type {
+  NormalizedBooleanOperationNode,
+  NormalizedRectangleNode,
+  NormalizedVectorNode,
+} from "@/normalizer";
+import { createElement, defineElementTransformer, type ElementTransformer } from "../../core";
+import type { PropsTransformers } from "./props";
+
+export interface RectangleTransformerDeps {
+  propsTransformers: PropsTransformers;
+}
+
+export function createRectangleTransformer({
+  propsTransformers,
+}: RectangleTransformerDeps): ElementTransformer<NormalizedRectangleNode> {
+  return defineElementTransformer((node: NormalizedRectangleNode, traverse) => {
+    return createElement(
+      "Box",
+      { ...propsTransformers.selfLayout(node, traverse), background: "palette.gray200" },
+      undefined,
+      "Rectangle Node Placeholder",
+    );
+  });
+}
+
+export function createVectorTransformer(): ElementTransformer<NormalizedVectorNode> {
+  return defineElementTransformer(() => {
+    return createElement("svg", {}, [], "Vector Node Placeholder");
+  });
+}
+
+export function createBooleanOperationTransformer(): ElementTransformer<NormalizedBooleanOperationNode> {
+  return defineElementTransformer(() => {
+    return createElement("svg", {}, [], "Boolean Operation Node Placeholder");
+  });
+}

package/src/codegen/targets/react/text.ts

@@ -0,0 +1,33 @@
+import type { NormalizedTextNode } from "@/normalizer";
+import { compactObject } from "@/utils/common";
+import { createElement, defineElementTransformer, type ElementTransformer } from "../../core";
+import type { PropsTransformers } from "./props";
+
+export interface TextTransformerDeps {
+  propsTransformers: PropsTransformers;
+}
+
+export function createTextTransformer({
+  propsTransformers,
+}: TextTransformerDeps): ElementTransformer<NormalizedTextNode> {
+  return defineElementTransformer((node: NormalizedTextNode, traverse) => {
+    const hasMultipleFills = node.fills.length > 1;
+
+    const fillProps = propsTransformers.textFill(node, traverse);
+    const typeStyleProps = propsTransformers.typeStyle(node, traverse);
+
+    const props = compactObject({
+      ...typeStyleProps,
+      ...fillProps,
+    });
+
+    return createElement(
+      "Text",
+      props,
+      node.characters.replace(/\n/g, "<br />"),
+      hasMultipleFills
+        ? "Multiple fills in Text node encountered, only the first fill is used."
+        : "",
+    );
+  });
+}

package/src/{codegen → entities}/data/icons.ts

@@ -1,4 +1,4 @@
-import type { IconData } from "../domain";
+import type { IconData } from "../icon.interface";
 
 export const FIGMA_ICONS: Record<string, IconData> = {
   "8b12671ecc2e0d9bd87c854fd10f7907bd06c54b": {

package/src/{codegen → entities}/data/styles.ts

@@ -1,4 +1,4 @@
-import type { Style } from "../domain";
+import type { Style } from "../style.interface";
 
 export const FIGMA_TEXT_STYLES: Style[] = [
   {

package/src/{codegen → entities}/data/variable-collections.ts

@@ -1,4 +1,4 @@
-import type { VariableCollection } from "../domain";
+import type { VariableCollection } from "../variable.interface";
 
 export const FIGMA_VARIABLE_COLLECTIONS: Record<string, VariableCollection> = {
   "VariableCollectionId:1:3": {

package/src/{codegen → entities}/data/variables.ts

@@ -1,4 +1,4 @@
-import type { Variable } from "../domain";
+import type { Variable } from "../variable.interface";
 
 export const FIGMA_VARIABLES: Record<string, Variable> = {
   "VariableID:1:129": {

package/src/entities/index.ts

@@ -0,0 +1,41 @@
+import { createStaticIconRepository } from "./icon.repository";
+import { FIGMA_ICONS } from "./data/icons";
+import { FIGMA_TEXT_STYLES } from "./data/styles";
+import { FIGMA_VARIABLE_COLLECTIONS } from "./data/variable-collections";
+import { FIGMA_VARIABLES } from "./data/variables";
+import { createStaticStyleRepository } from "./style.repository";
+import { createStaticVariableRepository } from "./variable.repository";
+
+export * from "./icon.interface";
+export * from "./icon.repository";
+export * from "./icon.service";
+export * from "./style.interface";
+export * from "./style.repository";
+export * from "./style.service";
+export * from "./variable.interface";
+export * from "./variable.repository";
+export * from "./variable.service";
+
+export const styleRepository = createStaticStyleRepository(FIGMA_TEXT_STYLES);
+export const variableRepository = createStaticVariableRepository({
+  variables: FIGMA_VARIABLES,
+  variableCollections: FIGMA_VARIABLE_COLLECTIONS,
+});
+export const iconRepository = createStaticIconRepository(FIGMA_ICONS);
+
+export function getFigmaVariableKey(name: string) {
+  return variableRepository.findVariableByName(name)?.key;
+}
+
+export function getFigmaStyleKey(name: string) {
+  return styleRepository.findOneByName(name)?.key;
+}
+
+export function getFigmaColorVariableNames(scopes: Array<"fg" | "bg" | "stroke" | "palette">) {
+  const variables = variableRepository.getVariableList();
+  return variables
+    .filter((variable) =>
+      scopes.includes(variable.name.split("/")[0] as "fg" | "bg" | "stroke" | "palette"),
+    )
+    .map((variable) => variable.name);
+}

package/src/{codegen/domain → entities}/style.repository.ts

@@ -4,20 +4,24 @@ export interface StyleRepository {
   getAll(): Style[];
   getTextStyles(): Style[];
   getColorStyles(): Style[];
-  getOne(key: string): Style | undefined;
+  findOneByKey(key: string): Style | undefined;
+  findOneByName(name: string): Style | undefined;
 }
 
 export function createStaticStyleRepository(styles: Style[]): StyleRepository {
   const stylesMap = new Map<string, Style>();
+  const stylesNameMap = new Map<string, Style>();
 
   for (const style of styles) {
     stylesMap.set(style.key, style);
+    stylesNameMap.set(style.name, style);
   }
 
   return {
     getAll: () => styles,
     getTextStyles: () => styles.filter((style) => style.styleType === "TEXT"),
     getColorStyles: () => styles.filter((style) => style.styleType === "FILL"),
-    getOne: (key) => stylesMap.get(key),
+    findOneByKey: (key) => stylesMap.get(key),
+    findOneByName: (name) => stylesNameMap.get(name),
   };
 }

package/src/{codegen/domain → entities}/style.service.ts

@@ -13,7 +13,7 @@ export function createStyleService({
   styleNameTransformer: ({ slug }: { slug: string[] }) => string;
 }): StyleService {
   function getFigmaStyleName(id: string) {
-    const style = styleRepository.getOne(id);
+    const style = styleRepository.findOneByKey(id);
 
     if (!style) {
       throw new Error(`Style not found: ${id}`);

package/src/{codegen/domain → entities}/variable.repository.ts

@@ -5,6 +5,7 @@ export interface VariableRepository {
   getVariableCollectionList(): VariableCollection[];
   findVariableByKey(key: string): Variable | undefined;
   findVariableById(id: string): Variable | undefined;
+  findVariableByName(name: string): Variable | undefined;
   findVariableCollectionByKey(key: string): VariableCollection | undefined;
   findVariableCollectionById(id: string): VariableCollection | undefined;
 }
@@ -18,24 +19,36 @@ export function createStaticVariableRepository({
 }): VariableRepository {
   const variablesKeyMap = new Map<string, Variable>();
   const variablesIdMap = new Map<string, Variable>();
+  const variablesNameMap = new Map<string, Variable>();
   const variableCollectionsKeyMap = new Map<string, VariableCollection>();
   const variableCollectionsIdMap = new Map<string, VariableCollection>();
-  const variablesList = Object.values(variables);
-  const variableCollectionsList = Object.values(variableCollections);
 
-  for (const variable of variablesList) {
+  for (const variable of Object.values(variables)) {
+    if (variable.remote) {
+      continue;
+    }
+
     variablesKeyMap.set(variable.key, variable);
     variablesIdMap.set(variable.id, variable);
+    variablesNameMap.set(variable.name, variable);
   }
 
-  for (const variableCollection of variableCollectionsList) {
+  for (const variableCollection of Object.values(variableCollections)) {
+    if (variableCollection.remote) {
+      continue;
+    }
+
     variableCollectionsKeyMap.set(variableCollection.key, variableCollection);
     variableCollectionsIdMap.set(variableCollection.id, variableCollection);
   }
 
+  const variablesList = [...variablesKeyMap.values()];
+  const variableCollectionsList = [...variableCollectionsKeyMap.values()];
+
   return {
     getVariableList: () => variablesList,
     getVariableCollectionList: () => variableCollectionsList,
+    findVariableByName: (name: string) => variablesNameMap.get(name),
     findVariableByKey: (key: string) => variablesKeyMap.get(key),
     findVariableById: (id: string) => variablesIdMap.get(id),
     findVariableCollectionByKey: (key: string) => variableCollectionsKeyMap.get(key),

package/src/{codegen/domain → entities}/variable.service.ts

@@ -4,17 +4,19 @@ import type { VariableRepository } from "./variable.repository";
 
 export interface VariableService {
   getVariableName: (id: string) => string;
-  inferVariableName: (scope: VariableScope, value: number | string | boolean) => string | undefined;
+  inferVariableName: (value: VariableValueResolved, scope: VariableScope) => string | undefined;
 }
 
 export interface VariableServiceDeps {
   variableRepository: VariableRepository;
   variableNameTransformer: ({ slug }: { slug: string[] }) => string;
+  inferCompareFunction: (name1: string, name2: string) => number;
 }
 
 export function createVariableService({
   variableRepository,
   variableNameTransformer,
+  inferCompareFunction,
 }: VariableServiceDeps): VariableService {
   const variables = variableRepository.getVariableList();
 
@@ -67,25 +69,61 @@ export function createVariableService({
     return value;
   }
 
+  function isIdenticalVariableValue(value1: VariableValueResolved, value2: VariableValueResolved) {
+    if (typeof value1 !== typeof value2) {
+      return false;
+    }
+
+    if (typeof value1 === "string" || typeof value1 === "number" || typeof value1 === "boolean") {
+      return value1 === value2;
+    }
+
+    return (
+      value1.r === (value2 as RGBA).r &&
+      value1.g === (value2 as RGBA).g &&
+      value1.b === (value2 as RGBA).b &&
+      value1.a === (value2 as RGBA).a
+    );
+  }
+
+  function isInsideScope(variable: Variable, scope: VariableScope) {
+    if (variable.scopes.includes("ALL_SCOPES")) {
+      return true;
+    }
+
+    if (variable.scopes.includes("ALL_FILLS")) {
+      if (scope === "FRAME_FILL" || scope === "SHAPE_FILL" || scope === "TEXT_FILL") {
+        return true;
+      }
+    }
+
+    return variable.scopes.includes(scope);
+  }
+
   // public
   function getVariableName(key: string) {
     const slug = getFigmaVariableSlug(key);
     return variableNameTransformer({ slug });
   }
 
-  function inferVariableName(scope: VariableScope, value: number | string | boolean) {
+  function inferVariableName(value: VariableValueResolved, scope: VariableScope) {
     // NOTE: We assume that the variable is in the default mode or value is equal between all modes for simplicity.
-    const inferredVariable = variables.find(
+    const inferredVariables = variables.filter(
       (variable) =>
-        variable.scopes.includes(scope) &&
-        resolveVariableValue(variable.id, getDefaultModeId(variable)) === value,
+        isInsideScope(variable, scope) &&
+        isIdenticalVariableValue(
+          resolveVariableValue(variable.id, getDefaultModeId(variable)),
+          value,
+        ),
     );
 
-    if (!inferredVariable) {
-      return undefined;
-    }
+    const inferredVariableNames = inferredVariables.map((variable) =>
+      getVariableName(variable.key),
+    );
+
+    const sortedVariableNames = inferredVariableNames.sort(inferCompareFunction);
 
-    return getVariableName(inferredVariable.key);
+    return sortedVariableNames[0];
   }
 
   return {

package/src/index.ts

@@ -1,2 +1,3 @@
 export * from "./normalizer";
 export * from "./codegen";
+export * from "./entities";