figmanage 1.0.0 → 1.1.0

package/dist/operations/branching.d.ts

@@ -0,0 +1,24 @@
+import type { AuthConfig } from '../auth/client.js';
+export interface Branch {
+    key: string;
+    name: string;
+    thumbnail_url: string | null;
+    last_modified: string | null;
+    link_access: string | null;
+}
+export interface CreatedBranch {
+    key: string | null;
+    name: string;
+    main_file_key: string;
+}
+export declare function listBranches(config: AuthConfig, params: {
+    file_key: string;
+}): Promise<Branch[]>;
+export declare function createBranch(config: AuthConfig, params: {
+    file_key: string;
+    name: string;
+}): Promise<CreatedBranch>;
+export declare function deleteBranch(config: AuthConfig, params: {
+    branch_key: string;
+}): Promise<void>;
+//# sourceMappingURL=branching.d.ts.map

package/dist/operations/branching.js

@@ -0,0 +1,41 @@
+import { hasCookie } from '../auth/client.js';
+import { publicClient } from '../clients/public-api.js';
+import { internalClient } from '../clients/internal-api.js';
+export async function listBranches(config, params) {
+    let branches;
+    if (hasCookie(config)) {
+        const res = await internalClient(config).get(`/api/files/${params.file_key}`);
+        const f = res.data?.meta || res.data;
+        branches = f.branches || [];
+    }
+    else {
+        const res = await publicClient(config).get(`/v1/files/${params.file_key}`, {
+            params: { branch_data: 'true', depth: '0' },
+        });
+        branches = res.data?.branches || [];
+    }
+    return branches.map((b) => ({
+        key: b.key,
+        name: b.name,
+        thumbnail_url: b.thumbnail_url || null,
+        last_modified: b.last_modified || null,
+        link_access: b.link_access || null,
+    }));
+}
+export async function createBranch(config, params) {
+    const res = await internalClient(config).post(`/api/multiplayer/${params.file_key}/branch_create?name=${encodeURIComponent(params.name)}`);
+    const meta = res.data?.meta || res.data || {};
+    const file = meta.file || meta;
+    const branchKey = file.key || file.file_key || null;
+    return {
+        key: branchKey,
+        name: params.name,
+        main_file_key: params.file_key,
+    };
+}
+export async function deleteBranch(config, params) {
+    await internalClient(config).delete('/api/files_batch', {
+        data: { files: [{ key: params.branch_key }], trashed: true },
+    });
+}
+//# sourceMappingURL=branching.js.map

package/dist/operations/comments.d.ts

@@ -0,0 +1,43 @@
+import type { AuthConfig } from '../auth/client.js';
+export interface Comment {
+    id: string;
+    parent_id: string | null;
+    message: string;
+    author: string;
+    author_id: string;
+    created_at: string;
+    resolved_at: string | null;
+    node_id: string | null;
+    order_id: number;
+}
+export interface PostedComment {
+    id: string;
+    message: string;
+    author: string;
+    created_at: string;
+    parent_id: string | null;
+}
+export interface Reaction {
+    emoji: string;
+    user: string;
+    created_at: string;
+}
+export declare function listComments(config: AuthConfig, params: {
+    file_key: string;
+}): Promise<Comment[]>;
+export declare function formatCommentsAsMarkdown(comments: Comment[]): string;
+export declare function postComment(config: AuthConfig, params: {
+    file_key: string;
+    message: string;
+    comment_id?: string;
+    node_id?: string;
+}): Promise<PostedComment>;
+export declare function deleteComment(config: AuthConfig, params: {
+    file_key: string;
+    comment_id: string;
+}): Promise<void>;
+export declare function listCommentReactions(config: AuthConfig, params: {
+    file_key: string;
+    comment_id: string;
+}): Promise<Reaction[]>;
+//# sourceMappingURL=comments.d.ts.map

package/dist/operations/comments.js

@@ -0,0 +1,65 @@
+import { publicClient } from '../clients/public-api.js';
+export async function listComments(config, params) {
+    const res = await publicClient(config).get(`/v1/files/${params.file_key}/comments`);
+    const comments = res.data?.comments || [];
+    return comments.map((c) => ({
+        id: c.id,
+        parent_id: c.parent_id || null,
+        message: c.message,
+        author: c.user?.handle,
+        author_id: c.user?.id,
+        created_at: c.created_at,
+        resolved_at: c.resolved_at || null,
+        node_id: c.client_meta?.node_id || c.client_meta?.node_offset?.node_id || null,
+        order_id: c.order_id,
+    }));
+}
+export function formatCommentsAsMarkdown(comments) {
+    const threads = new Map();
+    for (const c of comments) {
+        const parentId = c.parent_id || c.id;
+        if (!threads.has(parentId))
+            threads.set(parentId, []);
+        threads.get(parentId).push(c);
+    }
+    const lines = [];
+    for (const [, thread] of threads) {
+        thread.sort((a, b) => new Date(a.created_at).getTime() - new Date(b.created_at).getTime());
+        for (const c of thread) {
+            const indent = c.parent_id ? '  ' : '';
+            const resolved = c.resolved_at ? ' [resolved]' : '';
+            lines.push(`${indent}- **${c.author}** (${c.created_at})${resolved}: ${c.message}`);
+        }
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+export async function postComment(config, params) {
+    const body = { message: params.message };
+    if (params.comment_id)
+        body.comment_id = params.comment_id;
+    if (params.node_id)
+        body.client_meta = { node_id: params.node_id, node_offset: { x: 0, y: 0 } };
+    const res = await publicClient(config).post(`/v1/files/${params.file_key}/comments`, body);
+    const c = res.data;
+    return {
+        id: c.id,
+        message: c.message,
+        author: c.user?.handle,
+        created_at: c.created_at,
+        parent_id: c.parent_id || null,
+    };
+}
+export async function deleteComment(config, params) {
+    await publicClient(config).delete(`/v1/files/${params.file_key}/comments/${params.comment_id}`);
+}
+export async function listCommentReactions(config, params) {
+    const res = await publicClient(config).get(`/v1/files/${params.file_key}/comments/${params.comment_id}/reactions`);
+    const reactions = res.data?.reactions || [];
+    return reactions.map((r) => ({
+        emoji: r.emoji,
+        user: r.user?.handle,
+        created_at: r.created_at,
+    }));
+}
+//# sourceMappingURL=comments.js.map

package/dist/operations/components.d.ts

@@ -0,0 +1,24 @@
+import type { AuthConfig } from '../auth/client.js';
+export declare function listFileComponents(config: AuthConfig, params: {
+    file_key: string;
+}): Promise<any[]>;
+export declare function listFileStyles(config: AuthConfig, params: {
+    file_key: string;
+}): Promise<any[]>;
+export declare function listTeamComponents(config: AuthConfig, params: {
+    team_id: string;
+    page_size?: number;
+    cursor?: string;
+}): Promise<{
+    components: any[];
+    pagination: any;
+}>;
+export declare function listTeamStyles(config: AuthConfig, params: {
+    team_id: string;
+    page_size?: number;
+    cursor?: string;
+}): Promise<{
+    styles: any[];
+    pagination: any;
+}>;
+//# sourceMappingURL=components.d.ts.map

package/dist/operations/components.js

@@ -0,0 +1,30 @@
+import { publicClient } from '../clients/public-api.js';
+export async function listFileComponents(config, params) {
+    const res = await publicClient(config).get(`/v1/files/${params.file_key}/components`);
+    return res.data?.meta?.components || [];
+}
+export async function listFileStyles(config, params) {
+    const res = await publicClient(config).get(`/v1/files/${params.file_key}/styles`);
+    return res.data?.meta?.styles || [];
+}
+export async function listTeamComponents(config, params) {
+    const queryParams = { page_size: params.page_size ?? 30 };
+    if (params.cursor)
+        queryParams.after = params.cursor;
+    const res = await publicClient(config).get(`/v1/teams/${params.team_id}/components`, { params: queryParams });
+    return {
+        components: res.data?.meta?.components || [],
+        pagination: res.data?.pagination || null,
+    };
+}
+export async function listTeamStyles(config, params) {
+    const queryParams = { page_size: params.page_size ?? 30 };
+    if (params.cursor)
+        queryParams.after = params.cursor;
+    const res = await publicClient(config).get(`/v1/teams/${params.team_id}/styles`, { params: queryParams });
+    return {
+        styles: res.data?.meta?.styles || [],
+        pagination: res.data?.pagination || null,
+    };
+}
+//# sourceMappingURL=components.js.map

package/dist/operations/compound-manager.d.ts

@@ -0,0 +1,101 @@
+import type { AuthConfig } from '../auth/client.js';
+export declare function offboardUser(config: AuthConfig, params: {
+    user_identifier: string;
+    execute: boolean;
+    transfer_to?: string;
+    org_id?: string;
+}): Promise<{
+    user: {
+        org_user_id: string;
+        user_id: string;
+        name: any;
+        email: any;
+        seat_type: any;
+        permission: any;
+    };
+    team_memberships: {
+        team_id: string;
+        team_name: string;
+        role: string;
+    }[];
+    project_permissions: {
+        project_id: string;
+        project_name: string;
+        team_name: string;
+        role: string;
+    }[];
+    file_ownership: {
+        file_key: string;
+        file_name: string;
+        project_name: string;
+        team_name: string;
+    }[];
+    summary: {
+        teams: number;
+        projects_with_access: number;
+        files_owned: number;
+    };
+    transfer_plan: string[];
+    note: string;
+    executed?: undefined;
+    actions?: undefined;
+} | {
+    user: {
+        org_user_id: string;
+        user_id: string;
+        name: any;
+        email: any;
+        seat_type: any;
+        permission: any;
+    };
+    executed: boolean;
+    actions: {
+        action: string;
+        status: string;
+        detail?: string;
+    }[];
+    summary: {
+        succeeded: number;
+        failed: number;
+        total: number;
+    };
+    note: string;
+    team_memberships?: undefined;
+    project_permissions?: undefined;
+    file_ownership?: undefined;
+    transfer_plan?: undefined;
+}>;
+export declare function onboardUser(config: AuthConfig, params: {
+    email: string;
+    team_ids: string[];
+    role: string;
+    share_files?: string[];
+    seat_type?: string;
+    confirm?: boolean;
+    org_id?: string;
+}): Promise<{
+    user_email: string;
+    setup_results: {
+        teams_joined: {
+            team_id: string;
+            team_name: string;
+            role: string;
+            status: string;
+        }[];
+        files_shared: {
+            file_key: string;
+            role: string;
+            status: string;
+        }[];
+        seat_change: {
+            status: string;
+            note?: string;
+        };
+    };
+    next_steps: string[];
+}>;
+export declare function quarterlyDesignOpsReport(config: AuthConfig, params: {
+    org_id?: string;
+    days: number;
+}): Promise<Record<string, any>>;
+//# sourceMappingURL=compound-manager.d.ts.map