vimd 0.4.1 → 0.5.0

package/dist/core/folder-mode/folder-mode-server.js

@@ -0,0 +1,375 @@
+import http from 'http';
+import path from 'path';
+import fs from 'fs-extra';
+import { fileURLToPath } from 'url';
+import polka from 'polka';
+import { WebSocketServer as WSServer, WebSocket } from 'ws';
+import { Logger } from '../../utils/logger.js';
+import { SessionManager } from '../../utils/session-manager.js';
+import { ThemeManager } from '../../themes/index.js';
+import { ParserFactory } from '../parser/index.js';
+import { PandocDetector } from '../pandoc-detector.js';
+import { FileWatcher } from '../watcher.js';
+import { FolderScanner } from './folder-scanner.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+/**
+ * Folder mode server for multi-file preview
+ */
+export class FolderModeServer {
+    constructor(options) {
+        this.httpServer = null;
+        this.wsServer = null;
+        this.clients = new Map();
+        this.fileTree = [];
+        this.renderedHtml = null;
+        this.options = options;
+        this._port = options.port;
+        this.scanner = new FolderScanner({ rootPath: options.rootPath });
+    }
+    /**
+     * Get the actual port the server is running on
+     */
+    get port() {
+        return this._port;
+    }
+    /**
+     * Get the root path
+     */
+    get rootPath() {
+        return this.options.rootPath;
+    }
+    /**
+     * Start the HTTP and WebSocket servers
+     */
+    async start() {
+        const requestedPort = this.options.port;
+        let actualPort = requestedPort;
+        // Check if port is available
+        if (!(await SessionManager.isPortAvailable(requestedPort))) {
+            actualPort = await SessionManager.findAvailablePort(requestedPort + 1);
+            Logger.warn(`Port ${requestedPort} was unavailable, using port ${actualPort}`);
+        }
+        this._port = actualPort;
+        // Initial scan
+        this.fileTree = await this.scanner.scan();
+        Logger.info(`Found ${this.countFiles(this.fileTree)} files in folder`);
+        // Render template
+        this.renderedHtml = await this.renderTemplate();
+        // Create polka app
+        const app = polka();
+        // API: Get file tree
+        app.get('/api/tree', (_req, res) => {
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify(this.fileTree));
+        });
+        // Serve folder mode HTML for all routes (SPA style)
+        app.get('*', (req, res) => {
+            this.serveFolderModeHtml(req, res);
+        });
+        // Create HTTP server
+        this.httpServer = http.createServer(app.handler);
+        // Create WebSocket server
+        this.wsServer = new WSServer({ server: this.httpServer });
+        // Handle WebSocket connections
+        this.wsServer.on('connection', (ws) => {
+            this.handleConnection(ws);
+        });
+        // Start listening
+        await new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                reject(new Error('Server start timeout'));
+            }, 10000);
+            this.httpServer.listen(actualPort, 'localhost', () => {
+                clearTimeout(timeout);
+                resolve();
+            });
+            this.httpServer.on('error', (err) => {
+                clearTimeout(timeout);
+                reject(err);
+            });
+        });
+        const url = `http://localhost:${actualPort}`;
+        Logger.success(`Folder mode server started at ${url}`);
+        return {
+            actualPort,
+            requestedPort,
+            portChanged: actualPort !== requestedPort,
+        };
+    }
+    /**
+     * Stop the server
+     */
+    async stop() {
+        // Terminate all WebSocket clients
+        for (const [client] of this.clients) {
+            try {
+                client.terminate();
+            }
+            catch {
+                // Ignore termination errors
+            }
+        }
+        this.clients.clear();
+        // Close WebSocket server
+        if (this.wsServer) {
+            await new Promise((resolve) => {
+                this.wsServer.close(() => resolve());
+            });
+            this.wsServer = null;
+        }
+        // Close HTTP server
+        if (this.httpServer) {
+            this.httpServer.closeAllConnections();
+            await new Promise((resolve) => {
+                this.httpServer.close(() => resolve());
+            });
+            this.httpServer = null;
+        }
+        Logger.info('Folder mode server stopped');
+    }
+    /**
+     * Handle new WebSocket connection
+     */
+    handleConnection(ws) {
+        // Initialize client state
+        this.clients.set(ws, { currentFile: null, watcher: null });
+        Logger.info(`WebSocket client connected (${this.clients.size} total)`);
+        // Send file tree on connection
+        this.sendMessage(ws, { type: 'tree', data: this.fileTree });
+        // Handle messages from client
+        ws.on('message', (data) => {
+            try {
+                const message = JSON.parse(data.toString());
+                this.handleClientMessage(ws, message);
+            }
+            catch (error) {
+                Logger.warn(`Invalid message from client: ${error}`);
+            }
+        });
+        ws.on('close', async () => {
+            // Stop watcher for this client
+            const state = this.clients.get(ws);
+            if (state?.watcher) {
+                await state.watcher.stop();
+            }
+            this.clients.delete(ws);
+            Logger.info(`WebSocket client disconnected (${this.clients.size} remaining)`);
+        });
+        ws.on('error', async (error) => {
+            Logger.warn(`WebSocket error: ${error.message}`);
+            // Stop watcher for this client
+            const state = this.clients.get(ws);
+            if (state?.watcher) {
+                await state.watcher.stop();
+            }
+            this.clients.delete(ws);
+        });
+    }
+    /**
+     * Handle message from client
+     */
+    handleClientMessage(ws, message) {
+        switch (message.type) {
+            case 'selectFile':
+                this.handleSelectFile(ws, message.path);
+                break;
+            default:
+                Logger.warn(`Unknown message type: ${message.type}`);
+        }
+    }
+    /**
+     * Handle file selection
+     */
+    async handleSelectFile(ws, relativePath) {
+        const state = this.clients.get(ws);
+        if (!state)
+            return;
+        // Validate path (security check)
+        const absolutePath = this.validatePath(relativePath);
+        if (!absolutePath) {
+            this.sendMessage(ws, {
+                type: 'error',
+                data: { type: 'invalid-path', message: 'Invalid file path' },
+            });
+            return;
+        }
+        // Check file exists
+        if (!(await fs.pathExists(absolutePath))) {
+            this.sendMessage(ws, {
+                type: 'error',
+                data: { type: 'file-not-found', message: 'File not found' },
+            });
+            return;
+        }
+        // Determine file type
+        const ext = path.extname(relativePath).toLowerCase();
+        const isLatex = ext === '.tex' || ext === '.latex';
+        // Check pandoc for LaTeX files
+        if (isLatex && !PandocDetector.check()) {
+            this.sendMessage(ws, {
+                type: 'error',
+                data: {
+                    type: 'pandoc-not-found',
+                    message: 'LaTeX files require pandoc. Please install pandoc.',
+                },
+            });
+            return;
+        }
+        // Stop previous watcher if exists
+        if (state.watcher) {
+            await state.watcher.stop();
+            state.watcher = null;
+        }
+        // Convert file
+        try {
+            const html = await this.convertFile(absolutePath, isLatex);
+            // Update client state
+            state.currentFile = relativePath;
+            // Send content
+            this.sendMessage(ws, {
+                type: 'content',
+                data: { path: relativePath, html },
+            });
+            // Start watching the file
+            state.watcher = new FileWatcher(absolutePath, { debounce: 300, ignored: [] });
+            state.watcher.onChange(async () => {
+                // Re-convert and send on file change
+                try {
+                    const newHtml = await this.convertFile(absolutePath, isLatex);
+                    this.sendMessage(ws, {
+                        type: 'content',
+                        data: { path: relativePath, html: newHtml },
+                    });
+                    Logger.info(`File updated: ${relativePath}`);
+                }
+                catch (err) {
+                    const errMsg = err instanceof Error ? err.message : 'Unknown error';
+                    Logger.error(`Failed to reconvert ${relativePath}: ${errMsg}`);
+                }
+            });
+            state.watcher.start();
+            Logger.info(`File converted and watching: ${relativePath}`);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            Logger.error(`Failed to convert ${relativePath}: ${message}`);
+            this.sendMessage(ws, {
+                type: 'error',
+                data: { type: 'conversion-error', message: `Failed to convert file: ${message}` },
+            });
+        }
+    }
+    /**
+     * Convert a file to HTML
+     */
+    async convertFile(absolutePath, isLatex) {
+        const content = await fs.readFile(absolutePath, 'utf-8');
+        const fromFormat = isLatex ? 'latex' : 'markdown';
+        const parserType = isLatex ? 'pandoc' : 'markdown-it';
+        const parser = ParserFactory.create(parserType, {}, undefined, fromFormat);
+        return parser.parse(content);
+    }
+    /**
+     * Validate path and return absolute path if valid
+     */
+    validatePath(relativePath) {
+        // Normalize path
+        const normalized = path.normalize(relativePath);
+        // Reject paths with '..'
+        if (normalized.includes('..')) {
+            return null;
+        }
+        // Create absolute path
+        const absolutePath = path.join(this.options.rootPath, normalized);
+        // Ensure path is within root
+        if (!absolutePath.startsWith(this.options.rootPath)) {
+            return null;
+        }
+        return absolutePath;
+    }
+    /**
+     * Send message to a specific client
+     */
+    sendMessage(ws, message) {
+        if (ws.readyState === WebSocket.OPEN) {
+            ws.send(JSON.stringify(message));
+        }
+    }
+    /**
+     * Broadcast message to all clients
+     */
+    broadcast(message) {
+        const data = JSON.stringify(message);
+        for (const [client] of this.clients) {
+            if (client.readyState === WebSocket.OPEN) {
+                client.send(data);
+            }
+        }
+    }
+    /**
+     * Serve folder mode HTML
+     */
+    serveFolderModeHtml(_req, res) {
+        res.writeHead(200, {
+            'Content-Type': 'text/html; charset=utf-8',
+            'Cache-Control': 'no-cache, no-store, must-revalidate',
+        });
+        res.end(this.renderedHtml);
+    }
+    /**
+     * Render the folder mode template
+     */
+    async renderTemplate() {
+        // Load template
+        const templatePath = path.join(__dirname, '../../../templates/folder-mode.html');
+        let template = await fs.readFile(templatePath, 'utf-8');
+        // Load CSS
+        const cssPath = path.join(__dirname, 'assets/folder-mode.css');
+        const folderModeCss = await fs.readFile(cssPath, 'utf-8');
+        // Load JS
+        const jsPath = path.join(__dirname, 'assets/folder-mode.js');
+        const folderModeJs = await fs.readFile(jsPath, 'utf-8');
+        // Load theme CSS
+        const themeCss = await ThemeManager.getCSS(this.options.theme);
+        // Get folder name for display
+        const folderName = path.basename(this.options.rootPath);
+        // Replace placeholders
+        template = template
+            .replace('{{folder_name}}', this.escapeHtml(folderName))
+            .replace('{{folder_mode_css}}', folderModeCss)
+            .replace('{{theme_css}}', themeCss)
+            .replace('{{folder_mode_js}}', folderModeJs);
+        // Handle math support (enabled by default)
+        template = template
+            .replace(/\{\{#if math_enabled\}\}/g, '')
+            .replace(/\{\{\/if\}\}/g, '');
+        return template;
+    }
+    /**
+     * Escape HTML special characters
+     */
+    escapeHtml(text) {
+        return text
+            .replace(/&/g, '&')
+            .replace(/</g, '&lt;')
+            .replace(/>/g, '&gt;')
+            .replace(/"/g, '&quot;')
+            .replace(/'/g, '&#039;');
+    }
+    /**
+     * Count total files in tree
+     */
+    countFiles(nodes) {
+        let count = 0;
+        for (const node of nodes) {
+            if (node.type === 'file') {
+                count++;
+            }
+            else {
+                count += this.countFiles(node.children);
+            }
+        }
+        return count;
+    }
+}

package/dist/core/folder-mode/folder-scanner.d.ts

@@ -0,0 +1,34 @@
+import type { TreeNode, FolderScannerOptions } from './types.js';
+/**
+ * Folder scanner for building file tree structure
+ */
+export declare class FolderScanner {
+    private rootPath;
+    private excludePatterns;
+    constructor(options: FolderScannerOptions);
+    /**
+     * Scan the folder and return tree structure
+     */
+    scan(): Promise<TreeNode[]>;
+    /**
+     * Recursively scan a directory
+     */
+    private scanDirectory;
+    /**
+     * Check if a name is hidden (starts with .)
+     */
+    private isHidden;
+    /**
+     * Check if a name matches exclude patterns
+     */
+    private shouldExclude;
+    /**
+     * Check if extension is supported
+     */
+    private isSupportedExtension;
+    /**
+     * Sort nodes: folders first, then files, both in alphabetical order
+     */
+    private sortNodes;
+}
+//# sourceMappingURL=folder-scanner.d.ts.map

package/dist/core/folder-mode/folder-scanner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"folder-scanner.d.ts","sourceRoot":"","sources":["../../../src/core/folder-mode/folder-scanner.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,QAAQ,EAIR,oBAAoB,EACrB,MAAM,YAAY,CAAC;AAYpB;;GAEG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,eAAe,CAAW;gBAEtB,OAAO,EAAE,oBAAoB;IAQzC;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,QAAQ,EAAE,CAAC;IAIjC;;OAEG;YACW,aAAa;IAyD3B;;OAEG;IACH,OAAO,CAAC,QAAQ;IAIhB;;OAEG;IACH,OAAO,CAAC,aAAa;IAIrB;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAI5B;;OAEG;IACH,OAAO,CAAC,SAAS;CAUlB"}

package/dist/core/folder-mode/folder-scanner.js

@@ -0,0 +1,105 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+/**
+ * Default exclude patterns
+ */
+const DEFAULT_EXCLUDE_PATTERNS = ['node_modules', '.git', 'dist', 'build'];
+/**
+ * Supported file extensions
+ */
+const SUPPORTED_EXTENSIONS = ['.md', '.tex', '.latex'];
+/**
+ * Folder scanner for building file tree structure
+ */
+export class FolderScanner {
+    constructor(options) {
+        this.rootPath = options.rootPath;
+        this.excludePatterns = [
+            ...DEFAULT_EXCLUDE_PATTERNS,
+            ...(options.excludePatterns || []),
+        ];
+    }
+    /**
+     * Scan the folder and return tree structure
+     */
+    async scan() {
+        return this.scanDirectory(this.rootPath, '');
+    }
+    /**
+     * Recursively scan a directory
+     */
+    async scanDirectory(dirPath, relativePath) {
+        const entries = await fs.readdir(dirPath, { withFileTypes: true });
+        const nodes = [];
+        for (const entry of entries) {
+            const entryRelativePath = relativePath === '' ? entry.name : path.join(relativePath, entry.name);
+            // Skip hidden files/folders (except at root level when explicitly specified)
+            if (relativePath !== '' && this.isHidden(entry.name)) {
+                continue;
+            }
+            // Skip excluded patterns
+            if (this.shouldExclude(entry.name)) {
+                continue;
+            }
+            if (entry.isDirectory()) {
+                // Recursively scan subdirectory
+                const children = await this.scanDirectory(path.join(dirPath, entry.name), entryRelativePath);
+                // Only add folder if it has matching files
+                if (children.length > 0) {
+                    const folderNode = {
+                        name: entry.name,
+                        path: entryRelativePath,
+                        type: 'folder',
+                        children,
+                    };
+                    nodes.push(folderNode);
+                }
+            }
+            else if (entry.isFile()) {
+                const ext = path.extname(entry.name).toLowerCase();
+                // Only include supported extensions
+                if (this.isSupportedExtension(ext)) {
+                    const fileNode = {
+                        name: entry.name,
+                        path: entryRelativePath,
+                        type: 'file',
+                        extension: ext,
+                    };
+                    nodes.push(fileNode);
+                }
+            }
+        }
+        return this.sortNodes(nodes);
+    }
+    /**
+     * Check if a name is hidden (starts with .)
+     */
+    isHidden(name) {
+        return name.startsWith('.');
+    }
+    /**
+     * Check if a name matches exclude patterns
+     */
+    shouldExclude(name) {
+        return this.excludePatterns.includes(name);
+    }
+    /**
+     * Check if extension is supported
+     */
+    isSupportedExtension(ext) {
+        return SUPPORTED_EXTENSIONS.includes(ext);
+    }
+    /**
+     * Sort nodes: folders first, then files, both in alphabetical order
+     */
+    sortNodes(nodes) {
+        return nodes.sort((a, b) => {
+            // Folders come first
+            if (a.type !== b.type) {
+                return a.type === 'folder' ? -1 : 1;
+            }
+            // Alphabetical order (case-insensitive)
+            return a.name.toLowerCase().localeCompare(b.name.toLowerCase());
+        });
+    }
+}

package/dist/core/folder-mode/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Folder mode module exports
+ */
+export { FolderScanner } from './folder-scanner.js';
+export { FolderModeServer } from './folder-mode-server.js';
+export type { TreeNode, FileNode, FolderNode, SupportedExtension, FolderScannerOptions, FolderModeOptions, ServerMessage, ClientMessage, } from './types.js';
+export { isFileNode, isFolderNode } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/folder-mode/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/folder-mode/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAC3D,YAAY,EACV,QAAQ,EACR,QAAQ,EACR,UAAU,EACV,kBAAkB,EAClB,oBAAoB,EACpB,iBAAiB,EACjB,aAAa,EACb,aAAa,GACd,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC"}

package/dist/core/folder-mode/index.js

@@ -0,0 +1,6 @@
+/**
+ * Folder mode module exports
+ */
+export { FolderScanner } from './folder-scanner.js';
+export { FolderModeServer } from './folder-mode-server.js';
+export { isFileNode, isFolderNode } from './types.js';

package/dist/core/folder-mode/types.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Folder mode type definitions
+ */
+/**
+ * Supported file extensions for folder mode
+ */
+export type SupportedExtension = '.md' | '.tex' | '.latex';
+/**
+ * File node in the tree structure
+ */
+export interface FileNode {
+    /** File name (e.g., "plan.md") */
+    name: string;
+    /** Relative path from root (e.g., "docs/plan.md") */
+    path: string;
+    /** Node type */
+    type: 'file';
+    /** File extension */
+    extension: SupportedExtension;
+}
+/**
+ * Folder node in the tree structure
+ */
+export interface FolderNode {
+    /** Folder name (e.g., "docs") */
+    name: string;
+    /** Relative path from root (e.g., "docs") */
+    path: string;
+    /** Node type */
+    type: 'folder';
+    /** Child nodes (sorted) */
+    children: TreeNode[];
+}
+/**
+ * Tree node (file or folder)
+ */
+export type TreeNode = FileNode | FolderNode;
+/**
+ * Type guard for FileNode
+ */
+export declare function isFileNode(node: TreeNode): node is FileNode;
+/**
+ * Type guard for FolderNode
+ */
+export declare function isFolderNode(node: TreeNode): node is FolderNode;
+/**
+ * Folder scanner options
+ */
+export interface FolderScannerOptions {
+    /** Root path to scan */
+    rootPath: string;
+    /** Additional exclude patterns (glob) */
+    excludePatterns?: string[];
+}
+/**
+ * Folder mode server options
+ */
+export interface FolderModeOptions {
+    /** Root path of the folder */
+    rootPath: string;
+    /** Server port */
+    port: number;
+    /** Theme name */
+    theme: string;
+    /** Open browser on start */
+    open: boolean;
+}
+/**
+ * WebSocket message from server to client
+ */
+export type ServerMessage = {
+    type: 'tree';
+    data: TreeNode[];
+} | {
+    type: 'content';
+    data: {
+        path: string;
+        html: string;
+    };
+} | {
+    type: 'reload';
+} | {
+    type: 'error';
+    data: {
+        type: string;
+        message: string;
+    };
+} | {
+    type: 'fileDeleted';
+    data: {
+        path: string;
+    };
+};
+/**
+ * WebSocket message from client to server
+ */
+export type ClientMessage = {
+    type: 'selectFile';
+    path: string;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/core/folder-mode/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/core/folder-mode/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;GAEG;AACH,MAAM,MAAM,kBAAkB,GAAG,KAAK,GAAG,MAAM,GAAG,QAAQ,CAAC;AAE3D;;GAEG;AACH,MAAM,WAAW,QAAQ;IACvB,kCAAkC;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,qDAAqD;IACrD,IAAI,EAAE,MAAM,CAAC;IACb,gBAAgB;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,qBAAqB;IACrB,SAAS,EAAE,kBAAkB,CAAC;CAC/B;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,iCAAiC;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,6CAA6C;IAC7C,IAAI,EAAE,MAAM,CAAC;IACb,gBAAgB;IAChB,IAAI,EAAE,QAAQ,CAAC;IACf,2BAA2B;IAC3B,QAAQ,EAAE,QAAQ,EAAE,CAAC;CACtB;AAED;;GAEG;AACH,MAAM,MAAM,QAAQ,GAAG,QAAQ,GAAG,UAAU,CAAC;AAE7C;;GAEG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,QAAQ,GAAG,IAAI,IAAI,QAAQ,CAE3D;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,QAAQ,GAAG,IAAI,IAAI,UAAU,CAE/D;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,wBAAwB;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,yCAAyC;IACzC,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;CAC5B;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,8BAA8B;IAC9B,QAAQ,EAAE,MAAM,CAAC;IACjB,kBAAkB;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,iBAAiB;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,4BAA4B;IAC5B,IAAI,EAAE,OAAO,CAAC;CACf;AAED;;GAEG;AACH,MAAM,MAAM,aAAa,GACrB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,QAAQ,EAAE,CAAA;CAAE,GAClC;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAA;CAAE,GACzD;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,GAClB;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAA;CAAE,GAC1D;IAAE,IAAI,EAAE,aAAa,CAAC;IAAC,IAAI,EAAE;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,CAAA;CAAE,CAAC;AAEpD;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC"}

package/dist/core/folder-mode/types.js

@@ -0,0 +1,15 @@
+/**
+ * Folder mode type definitions
+ */
+/**
+ * Type guard for FileNode
+ */
+export function isFileNode(node) {
+    return node.type === 'file';
+}
+/**
+ * Type guard for FolderNode
+ */
+export function isFolderNode(node) {
+    return node.type === 'folder';
+}