@animaapp/anima-sdk 0.2.1 → 0.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@animaapp/anima-sdk",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "type": "module",
   "description": "Anima's JavaScript utilities library",
   "author": "Anima App, Inc.",
@@ -34,4 +34,4 @@
     "vite-tsconfig-paths": "^5.1.4",
     "vitest": "^3.0.5"
   }
-}
+}

package/src/anima.ts

@@ -9,7 +9,7 @@ import {
 
 export type Auth =
   | { token: string; teamId: string } // for Anima user, it's mandatory to have an associated team
-  | { token: string; userId?: string }; // for users from a 3rd-party client (e.g., Bolt) they may have optionally a user id
+  | { token: string; userId?: string }; // for users from a 3rd-party integrations, they may have optionally a user id
 
 export class Anima {
   #auth?: Auth;
@@ -84,6 +84,7 @@ export class Anima {
         uiLibrary: settings.uiLibrary,
         enableTranslation: settings.enableTranslation,
         enableUILibraryTheming: settings.enableUILibraryTheming,
+        enableCompactStructure: settings.enableCompactStructure,
       }),
     });
 
@@ -225,6 +226,7 @@ export class Anima {
                     reason: "No files found",
                   });
                 }
+                result.tokenUsage = data.payload.tokenUsage;
                 return result as AnimaSDKResult;
               }
             }

package/src/dataStream.ts

@@ -38,7 +38,12 @@ export const createCodegenStream = (
           }
         })
         .then((_result) => {
-          controller.enqueue({ type: "done" });
+          controller.enqueue({
+            type: "done", payload: {
+              tokenUsage: _result.tokenUsage,
+              sessionId: _result.sessionId,
+            }
+          });
           controller.close();
         })
         .catch((error) => {

package/src/settings.ts

@@ -20,6 +20,7 @@ const CodegenSettingsSchema = z
         ]),
         uiLibrary: z.enum(["mui", "antd", "radix", "shadcn"]).optional(),
         enableUILibraryTheming: z.boolean().optional(),
+        enableCompactStructure: z.boolean().optional(),
       }),
       z.object({
         framework: z.literal("html"),
@@ -32,7 +33,7 @@ const CodegenSettingsSchema = z
 // We don't use the z.infer method here because the types returned by zod aren't ergonic
 export type CodegenSettings = {
   language?: "typescript" | "javascript";
-  model?: string,
+  model?: string;
   framework: "react" | "html";
   styling:
     | "plain_css"
@@ -41,10 +42,11 @@ export type CodegenSettings = {
     | "tailwind"
     | "sass"
     | "scss"
-    | "inline_styles"
+    | "inline_styles";
   uiLibrary?: "mui" | "antd" | "radix" | "shadcn";
   enableTranslation?: boolean;
   enableUILibraryTheming?: boolean;
+  enableCompactStructure?: boolean;
 };
 
 export const validateSettings = (obj: unknown): CodegenSettings => {

package/src/types.ts

@@ -13,6 +13,7 @@ export type BaseResult = {
   sessionId: string;
   figmaFileName: string;
   figmaSelectedFrameName: string;
+  tokenUsage: number;
 };
 
 export type AnimaSDKResult = BaseResult & {
@@ -39,32 +40,32 @@ export type GetCodeParams = {
 export type GetCodeHandler =
   | ((message: SSECodgenMessage) => void)
   | {
-      onStart?: ({ sessionId }: { sessionId: string }) => void;
-      onPreCodegen?: ({ message }: { message: string }) => void;
-      onAssetsUploaded?: () => void;
-      onAssetsList?: ({
-        assets,
-      }: {
-        assets: Array<{ name: string; url: string }>;
-      }) => void;
-      onFigmaMetadata?: ({
-        figmaFileName,
-        figmaSelectedFrameName,
-      }: {
-        figmaFileName: string;
-        figmaSelectedFrameName: string;
-      }) => void;
-      onGeneratingCode?: ({
-        status,
-        progress,
-        files,
-      }: {
-        status: "success" | "running" | "failure";
-        progress: number;
-        files: AnimaFiles;
-      }) => void;
-      onCodegenCompleted?: () => void;
-    };
+    onStart?: ({ sessionId }: { sessionId: string }) => void;
+    onPreCodegen?: ({ message }: { message: string }) => void;
+    onAssetsUploaded?: () => void;
+    onAssetsList?: ({
+      assets,
+    }: {
+      assets: Array<{ name: string; url: string }>;
+    }) => void;
+    onFigmaMetadata?: ({
+      figmaFileName,
+      figmaSelectedFrameName,
+    }: {
+      figmaFileName: string;
+      figmaSelectedFrameName: string;
+    }) => void;
+    onGeneratingCode?: ({
+      status,
+      progress,
+      files,
+    }: {
+      status: "success" | "running" | "failure";
+      progress: number;
+      files: AnimaFiles;
+    }) => void;
+    onCodegenCompleted?: () => void;
+  };
 
 export type GeneratingCodePayload = {
   status: "success" | "running" | "failure";
@@ -77,20 +78,20 @@ export type SSECodgenMessage =
   | { type: "start"; sessionId: string }
   | { type: "pre_codegen"; message: string }
   | {
-      type: "figma_metadata";
-      figmaFileName: string;
-      figmaSelectedFrameName: string;
-    }
+    type: "figma_metadata";
+    figmaFileName: string;
+    figmaSelectedFrameName: string;
+  }
   | { type: "generating_code"; payload: GeneratingCodePayload }
   | { type: "codegen_completed" }
   | { type: "assets_uploaded" }
   | {
-      type: "assets_list";
-      payload: { assets: Array<{ name: string; url: string }> };
-    }
+    type: "assets_list";
+    payload: { assets: Array<{ name: string; url: string }> };
+  }
   | { type: "aborted" }
   | { type: "error"; payload: SSECodgenMessageErrorPayload }
-  | { type: "done" };
+  | { type: "done", payload: { sessionId: string, tokenUsage: number } };
 export type SSECodgenMessageErrorPayload = {
   errorName: string;
   task?: string;

package/src/utils/files.ts

@@ -0,0 +1,95 @@
+import { AnimaFiles } from "../types";
+
+export const getRelatedScreenFiles = ({
+  files,
+  screenPath = "src/screens",
+}: {
+  files: AnimaFiles;
+  screenPath?: string;
+}) => {
+  const result: AnimaFiles = {};
+  const processed = new Set<string>();
+
+  function processFile(filePath: string) {
+    if (processed.has(filePath) || !files[filePath]) {
+      return;
+    }
+
+    processed.add(filePath);
+    result[filePath] = files[filePath];
+
+    const imports = parseImports(files[filePath].content);
+
+    imports.forEach((importPath) => {
+      try {
+        const resolvedPath = resolveImportPath(filePath, importPath);
+
+        if (resolvedPath.startsWith("src/")) {
+          const importDir = resolvedPath.split("/").slice(0, -1).join("/");
+          const dirFiles = getAllFilesInDirectory(files, importDir);
+          dirFiles.forEach((file) => {
+            if (!processed.has(file)) {
+              processFile(file);
+            }
+          });
+        }
+      } catch (error) {
+        console.warn(
+          `Failed to resolve import ${importPath} in ${filePath}:`,
+          error
+        );
+      }
+    });
+  }
+
+  Object.entries(files).forEach(([key, value]) => {
+    if (key.startsWith(screenPath)) {
+      processFile(key);
+    } else if (!key.startsWith("src/")) {
+      result[key] = value;
+    }
+  });
+
+  return result;
+};
+
+function parseImports(content: string): string[] {
+  const importRegex = /import.*?["']([^"']+)["']/g;
+  const exports = /export.*from\s+["']([^"']+)["']/g;
+  const imports: string[] = [];
+  let match;
+
+  while ((match = importRegex.exec(content)) !== null) {
+    imports.push(match[1]);
+  }
+
+  while ((match = exports.exec(content)) !== null) {
+    imports.push(match[1]);
+  }
+
+  return [...new Set(imports)];
+}
+
+function resolveImportPath(basePath: string, importPath: string): string {
+  if (!importPath.startsWith(".")) {
+    return importPath;
+  }
+
+  const baseDir = basePath.split("/").slice(0, -1);
+  const importParts = importPath.split("/");
+  const resolvedParts: string[] = [...baseDir];
+
+  for (const part of importParts) {
+    if (part === "..") {
+      resolvedParts.pop();
+    } else if (part !== ".") {
+      resolvedParts.push(part);
+    }
+  }
+
+  return resolvedParts.join("/");
+}
+
+function getAllFilesInDirectory(files: AnimaFiles, dirPath: string): string[] {
+  return Object.keys(files).filter((file) => file.startsWith(dirPath));
+}

package/src/utils/index.ts

@@ -0,0 +1,2 @@
+export * from "./figma";
+export * from "./files";