listpage-next 0.0.246 → 0.0.247

package/dist/ui/FileManager/services/storageService.js

@@ -0,0 +1,249 @@
+import { DeleteObjectCommand, ListObjectsV2Command, PutObjectCommand, S3Client } from "@aws-sdk/client-s3";
+import { getStorageConfig } from "./config.js";
+const getS3Client = ()=>{
+    const cfg = getStorageConfig();
+    return new S3Client({
+        region: cfg.region || 'us-east-1',
+        endpoint: cfg.endpoint,
+        credentials: {
+            accessKeyId: cfg.accessKeyId,
+            secretAccessKey: cfg.secretAccessKey
+        },
+        forcePathStyle: true
+    });
+};
+const listAssets = async ()=>{
+    try {
+        const cfg = getStorageConfig();
+        const s3 = getS3Client();
+        const command = new ListObjectsV2Command({
+            Bucket: cfg.bucketName
+        });
+        const response = await s3.send(command);
+        const assets = [];
+        const foldersMap = new Map();
+        const getParentPath = (path)=>{
+            const cleanPath = path.endsWith('/') ? path.slice(0, -1) : path;
+            const parts = cleanPath.split('/');
+            if (parts.length <= 1) return null;
+            parts.pop();
+            return parts.join('/') + '/';
+        };
+        const ensureFolderExists = (path, date)=>{
+            if (!path || foldersMap.has(path)) return;
+            const parentId = getParentPath(path);
+            if (parentId) ensureFolderExists(parentId, date);
+            const cleanPath = path.slice(0, -1);
+            const name = cleanPath.split('/').pop() || 'Unknown';
+            foldersMap.set(path, {
+                id: path,
+                name: name,
+                parentId: parentId,
+                createdAt: date.toISOString(),
+                type: 'folder'
+            });
+        };
+        (response.Contents || []).forEach((item)=>{
+            const key = item.Key || '';
+            const date = item.LastModified || new Date();
+            if (key.endsWith('/')) return void ensureFolderExists(key, date);
+            const parts = key.split('/');
+            let parentId = null;
+            if (parts.length > 1) {
+                parts.pop();
+                parentId = parts.join('/') + '/';
+                ensureFolderExists(parentId, date);
+            }
+            const ext = key.split('.').pop()?.toLowerCase();
+            let type = 'file';
+            if ([
+                'png',
+                'jpg',
+                'jpeg',
+                'gif',
+                'webp',
+                'svg'
+            ].includes(ext || '')) type = 'image';
+            else if ([
+                'mp4',
+                'webm',
+                'mov',
+                'avi'
+            ].includes(ext || '')) type = 'video';
+            else if ([
+                'mp3',
+                'wav',
+                'ogg'
+            ].includes(ext || '')) type = 'audio';
+            else if ([
+                'obj',
+                'fbx',
+                'glb',
+                'gltf'
+            ].includes(ext || '')) type = 'model';
+            const url = `${cfg.endpoint}/${cfg.bucketName}/${key}`;
+            const name = key.split('/').pop() || key;
+            assets.push({
+                id: key,
+                name: name,
+                url: url,
+                type: type,
+                width: 0,
+                height: 0,
+                size: formatBytes(item.Size || 0),
+                createdAt: date.toISOString(),
+                source: 'upload',
+                parentId: parentId
+            });
+        });
+        return {
+            assets,
+            folders: Array.from(foldersMap.values())
+        };
+    } catch (error) {
+        console.error('List assets failed', error);
+        return {
+            assets: [],
+            folders: []
+        };
+    }
+};
+const createFolder = async (folderName, parentPath)=>{
+    const prefix = parentPath ? parentPath : '';
+    const key = `${prefix}${folderName}/`;
+    try {
+        const cfg = getStorageConfig();
+        const s3 = getS3Client();
+        const command = new PutObjectCommand({
+            Bucket: cfg.bucketName,
+            Key: key,
+            Body: new Uint8Array(0)
+        });
+        await s3.send(command);
+        return {
+            id: key,
+            name: folderName,
+            parentId: parentPath,
+            createdAt: new Date().toISOString(),
+            type: 'folder'
+        };
+    } catch (error) {
+        console.error('Create folder failed', error);
+        throw error;
+    }
+};
+const deleteFolder = async (folderPath)=>{
+    try {
+        const cfg = getStorageConfig();
+        const s3 = getS3Client();
+        let continuationToken;
+        do {
+            const listResp = await s3.send(new ListObjectsV2Command({
+                Bucket: cfg.bucketName,
+                Prefix: folderPath,
+                ContinuationToken: continuationToken
+            }));
+            const contents = listResp.Contents || [];
+            for (const item of contents){
+                const key = item.Key;
+                if (key) await s3.send(new DeleteObjectCommand({
+                    Bucket: cfg.bucketName,
+                    Key: key
+                }));
+            }
+            continuationToken = listResp.IsTruncated ? listResp.NextContinuationToken : void 0;
+        }while (continuationToken);
+    } catch (error) {
+        console.error('Recursive delete failed', error);
+        throw error;
+    }
+};
+const uploadObject = async (file, folderId)=>{
+    const prefix = folderId || '';
+    const cleanName = file.name.replace(/[^a-zA-Z0-9.-]/g, '_');
+    const key = `${prefix}${Date.now()}-${cleanName}`;
+    try {
+        const cfg = getStorageConfig();
+        const s3 = getS3Client();
+        const buffer = await file.arrayBuffer();
+        const body = new Uint8Array(buffer);
+        const command = new PutObjectCommand({
+            Bucket: cfg.bucketName,
+            Key: key,
+            Body: body,
+            ContentType: file.type
+        });
+        await s3.send(command);
+        const publicUrl = `${cfg.endpoint}/${cfg.bucketName}/${key}`;
+        let type = 'file';
+        if (file.type.startsWith('image/')) type = 'image';
+        else if (file.type.startsWith('video/')) type = 'video';
+        else if (file.type.startsWith('audio/')) type = 'audio';
+        else if (file.name.endsWith('.obj') || file.name.endsWith('.fbx') || file.name.endsWith('.glb')) type = 'model';
+        let width, height;
+        if ('image' === type) try {
+            const dimensions = await getImageDimensions(publicUrl);
+            width = dimensions.width;
+            height = dimensions.height;
+        } catch (e) {}
+        return {
+            id: key,
+            name: key.split('/').pop(),
+            url: publicUrl,
+            type,
+            width,
+            height,
+            size: formatBytes(file.size),
+            createdAt: new Date().toISOString(),
+            source: 'upload',
+            parentId: folderId
+        };
+    } catch (error) {
+        console.error('Upload failed', error);
+        throw new Error('Failed to upload to storage');
+    }
+};
+const deleteObject = async (assetId)=>{
+    try {
+        const cfg = getStorageConfig();
+        const s3 = getS3Client();
+        const command = new DeleteObjectCommand({
+            Bucket: cfg.bucketName,
+            Key: assetId
+        });
+        await s3.send(command);
+    } catch (error) {
+        console.error('Delete failed', error);
+    }
+};
+const getImageDimensions = (url)=>new Promise((resolve, reject)=>{
+        const img = new Image();
+        img.onload = ()=>resolve({
+                width: img.width,
+                height: img.height
+            });
+        img.onerror = reject;
+        img.src = url;
+    });
+const formatBytes = (bytes, decimals = 2)=>{
+    if (!+bytes) return '0 Bytes';
+    const k = 1024;
+    const dm = decimals < 0 ? 0 : decimals;
+    const sizes = [
+        'Bytes',
+        'KB',
+        'MB',
+        'GB',
+        'TB'
+    ];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return `${parseFloat((bytes / Math.pow(k, i)).toFixed(dm))} ${sizes[i]}`;
+};
+const adapter = {
+    createFolder,
+    deleteFolder,
+    uploadObject,
+    deleteObject,
+    listAssets
+};
+export { adapter, createFolder, deleteFolder, deleteObject, listAssets, uploadObject };

package/dist/ui/FileManager/types.d.ts

@@ -0,0 +1,36 @@
+export interface Folder {
+    id: string;
+    name: string;
+    parentId: string | null;
+    createdAt: string;
+    type: 'folder';
+}
+export type AssetType = 'image' | 'video' | 'audio' | 'model' | 'file';
+export interface Asset {
+    id: string;
+    name: string;
+    url: string;
+    type: AssetType;
+    parentId: string | null;
+    width?: number;
+    height?: number;
+    size?: string;
+    createdAt: string;
+    source: 'upload' | 'ai-generated';
+}
+export type FileSystemItem = Folder | Asset;
+export type ViewMode = 'grid' | 'list';
+export interface FilterState {
+    search: string;
+    source: 'all' | 'upload' | 'ai-generated';
+}
+export interface StorageAdapter {
+    listAssets: () => Promise<{
+        assets: Asset[];
+        folders: Folder[];
+    }>;
+    createFolder: (name: string, parentPath: string | null) => Promise<Folder>;
+    deleteFolder: (folderPath: string) => Promise<void>;
+    deleteObject: (assetId: string) => Promise<void>;
+    uploadObject: (file: File, folderId: string | null) => Promise<Partial<Asset>>;
+}

package/dist/ui/Modal/ConfirmModal.d.ts

@@ -0,0 +1,11 @@
+import { ReactNode } from 'react';
+export interface ConfirmModalProps {
+    open?: boolean;
+    onOk?: () => void;
+    onCancel?: () => void;
+    type?: 'error';
+    title?: ReactNode;
+    children?: ReactNode;
+    className?: string;
+}
+export declare const ConfirmModal: (props: ConfirmModalProps) => import("react/jsx-runtime").JSX.Element;

package/dist/ui/Modal/ConfirmModal.js

@@ -0,0 +1,62 @@
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { AlertTriangle, X } from "lucide-react";
+import { Button } from "../Button/index.js";
+const ConfirmModal = (props)=>{
+    const { title, onCancel, onOk, children, open, type, className = '' } = props;
+    if (!open) return /*#__PURE__*/ jsx(Fragment, {});
+    return /*#__PURE__*/ jsx("div", {
+        className: `flex items-center justify-center bg-black/80 backdrop-blur-sm p-4 ${className}`,
+        children: /*#__PURE__*/ jsxs("div", {
+            className: "bg-slate-900 border border-slate-700 w-full max-w-sm rounded-xl shadow-2xl p-6 transform transition-all scale-100",
+            children: [
+                /*#__PURE__*/ jsxs("div", {
+                    className: "flex items-center justify-between mb-4",
+                    children: [
+                        /*#__PURE__*/ jsxs("div", {
+                            className: "flex items-center gap-1",
+                            children: [
+                                /*#__PURE__*/ jsx("div", {
+                                    className: "rounded-full bg-red-900/30 flex items-center justify-center",
+                                    children: /*#__PURE__*/ jsx(AlertTriangle, {
+                                        className: "w-5 h-5 text-red-500"
+                                    })
+                                }),
+                                /*#__PURE__*/ jsx("h2", {
+                                    className: "text-lg font-bold text-white mb-0",
+                                    children: title
+                                })
+                            ]
+                        }),
+                        /*#__PURE__*/ jsx("button", {
+                            onClick: onCancel,
+                            className: "text-slate-400 hover:text-white transition-colors",
+                            children: /*#__PURE__*/ jsx(X, {
+                                className: "w-5 h-5"
+                            })
+                        })
+                    ]
+                }),
+                /*#__PURE__*/ jsx("p", {
+                    className: "text-slate-400 text-sm mb-6",
+                    children: children
+                }),
+                /*#__PURE__*/ jsxs("div", {
+                    className: "flex justify-end gap-3",
+                    children: [
+                        /*#__PURE__*/ jsx(Button, {
+                            onClick: onCancel,
+                            type: "text",
+                            children: "取消"
+                        }),
+                        /*#__PURE__*/ jsx(Button, {
+                            type: "error",
+                            onClick: onOk,
+                            children: "删除"
+                        })
+                    ]
+                })
+            ]
+        })
+    });
+};
+export { ConfirmModal };

package/dist/ui/Modal/Modal.d.ts

@@ -0,0 +1,14 @@
+import { ReactNode } from 'react';
+import { ButtonProps } from '../Button';
+export interface ModalProps {
+    open?: boolean;
+    onCancel?: () => void;
+    onOk?: () => void;
+    title?: ReactNode;
+    children?: ReactNode;
+    headerExtra?: ReactNode;
+    okButtonProps?: ButtonProps;
+    cancelButtonProps?: ButtonProps;
+    className?: string;
+}
+export declare const Modal: (props: ModalProps) => import("react/jsx-runtime").JSX.Element;

package/dist/ui/Modal/Modal.js

@@ -0,0 +1,64 @@
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { X } from "lucide-react";
+import { Button } from "../Button/index.js";
+const Modal = (props)=>{
+    const { open, onCancel, onOk, title, children, headerExtra, okButtonProps, cancelButtonProps, className = '' } = props;
+    if (!open) return /*#__PURE__*/ jsx(Fragment, {});
+    return /*#__PURE__*/ jsx("div", {
+        className: `fixed inset-0 z-50 flex items-center justify-center bg-black/80 backdrop-blur-sm p-4 ${className}`,
+        children: /*#__PURE__*/ jsxs("div", {
+            className: "bg-slate-950 border border-slate-700 w-full max-w-5xl h-[85vh] rounded-2xl shadow-2xl flex flex-col overflow-hidden",
+            children: [
+                /*#__PURE__*/ jsxs("div", {
+                    className: "flex items-center justify-between px-6 py-4 border-b border-slate-800 bg-slate-900",
+                    children: [
+                        /*#__PURE__*/ jsx("h2", {
+                            className: "text-xl font-bold text-white flex items-center gap-2",
+                            children: title
+                        }),
+                        /*#__PURE__*/ jsxs("div", {
+                            className: "flex items-center gap-4",
+                            children: [
+                                /*#__PURE__*/ jsx("div", {
+                                    className: "relative",
+                                    children: headerExtra
+                                }),
+                                /*#__PURE__*/ jsx("button", {
+                                    onClick: onCancel,
+                                    className: "text-slate-400 hover:text-white transition-colors",
+                                    children: /*#__PURE__*/ jsx(X, {
+                                        className: "w-6 h-6"
+                                    })
+                                })
+                            ]
+                        })
+                    ]
+                }),
+                /*#__PURE__*/ jsx("div", {
+                    className: "flex-1 flex overflow-hidden",
+                    children: /*#__PURE__*/ jsx("div", {
+                        className: "flex-1 bg-slate-950 relative",
+                        children: children
+                    })
+                }),
+                /*#__PURE__*/ jsxs("div", {
+                    className: "p-4 border-t border-slate-800 bg-slate-900 flex justify-end gap-3",
+                    children: [
+                        /*#__PURE__*/ jsx(Button, {
+                            onClick: onCancel,
+                            type: "text",
+                            ...cancelButtonProps,
+                            children: "取消"
+                        }),
+                        /*#__PURE__*/ jsx(Button, {
+                            onClick: onOk,
+                            ...okButtonProps,
+                            children: "确认"
+                        })
+                    ]
+                })
+            ]
+        })
+    });
+};
+export { Modal };

package/dist/ui/Modal/index.d.ts

@@ -0,0 +1,2 @@
+export { ConfirmModal, type ConfirmModalProps } from './ConfirmModal';
+export { Modal, type ModalProps } from './Modal';

package/dist/ui/Modal/index.js

@@ -0,0 +1,3 @@
+import { ConfirmModal } from "./ConfirmModal.js";
+import { Modal } from "./Modal.js";
+export { ConfirmModal, Modal };

package/dist/ui/index.d.ts

@@ -4,3 +4,4 @@ export { LogPreview, type LogPreviewProps, type LogEntry } from './LogPreview';
 export { StatusTag, type StatusTagProps } from './StatusTag';
 export { Tabs, type TabsProps } from './Tabs';
 export { Menu, type MenuProps } from './Menu';
+export { FileManager, AssetSelectorModal } from './FileManager';

package/dist/ui/index.js

@@ -4,4 +4,5 @@ import { LogPreview } from "./LogPreview/index.js";
 import { StatusTag } from "./StatusTag/index.js";
 import { Tabs } from "./Tabs/index.js";
 import { Menu } from "./Menu/index.js";
-export { Button, LogPreview, Menu, PromptEditor, StatusTag, Tabs };
+import { AssetSelectorModal, FileManager } from "./FileManager/index.js";
+export { AssetSelectorModal, Button, FileManager, LogPreview, Menu, PromptEditor, StatusTag, Tabs };