colonynote 0.0.0 → 1.0.0-beta.12

package/dist/server/ignore.js

@@ -0,0 +1,210 @@
+import path from 'path';
+import fs from 'fs';
+import { minimatch } from 'minimatch';
+/**
+ * 默认忽略配置
+ */
+export const defaultIgnoreConfig = {
+    enableIgnoreFiles: true,
+    ignoreFileNames: ['.colonynoteignore', '.gitignore'],
+    globalPatterns: [],
+};
+/**
+ * 忽略匹配器 - 管理所有忽略规则并提供匹配功能
+ */
+export class IgnoreMatcher {
+    ignoreFiles = new Map();
+    globalRules = [];
+    rootPath;
+    config;
+    constructor(rootPath, config = defaultIgnoreConfig) {
+        this.rootPath = path.resolve(rootPath);
+        this.config = config;
+        this.globalRules = this.parsePatterns(config.globalPatterns, this.rootPath);
+    }
+    /**
+     * 解析忽略模式字符串为规则对象
+     */
+    parsePatterns(patterns, basePath) {
+        const rules = [];
+        for (const rawPattern of patterns) {
+            // 跳过空行和注释
+            const trimmed = rawPattern.trim();
+            if (!trimmed || trimmed.startsWith('#'))
+                continue;
+            const isNegation = trimmed.startsWith('!');
+            const isDirectory = trimmed.endsWith('/');
+            // 处理模式字符串
+            let pattern = trimmed;
+            // 处理否定模式：移除开头的 !
+            if (isNegation) {
+                pattern = pattern.slice(1);
+            }
+            // 处理目录标记：暂时保留，匹配时再处理
+            const cleanPattern = isDirectory ? pattern.slice(0, -1) : pattern;
+            // 判断是否为绝对路径模式（以 / 开头）
+            const isAbsolute = cleanPattern.startsWith('/');
+            const rule = {
+                pattern: cleanPattern,
+                rawPattern: trimmed,
+                isNegation,
+                isDirectory,
+                basePath,
+                isAbsolute,
+            };
+            rules.push(rule);
+        }
+        return rules;
+    }
+    /**
+     * 加载指定路径的 .ignore 文件
+     */
+    loadIgnoreFile(filePath) {
+        try {
+            if (!fs.existsSync(filePath))
+                return false;
+            const content = fs.readFileSync(filePath, 'utf-8');
+            const lines = content.split(/\r?\n/);
+            const basePath = path.dirname(filePath);
+            const ignoreFile = {
+                filePath,
+                basePath,
+                rules: this.parsePatterns(lines, basePath),
+            };
+            this.ignoreFiles.set(filePath, ignoreFile);
+            return true;
+        }
+        catch (e) {
+            console.error(`Failed to load ignore file ${filePath}:`, e);
+            return false;
+        }
+    }
+    /**
+     * 就近查找并加载 .ignore 文件
+     * 从 targetPath 向上查找，直到 rootPath
+     */
+    findAndLoadIgnoreFiles(targetPath) {
+        if (!this.config.enableIgnoreFiles)
+            return;
+        let currentPath = path.resolve(targetPath);
+        // 如果是文件，从其父目录开始查找
+        try {
+            const stat = fs.statSync(currentPath);
+            if (stat.isFile()) {
+                currentPath = path.dirname(currentPath);
+            }
+        }
+        catch {
+            // 路径不存在，假设是目录
+        }
+        while (currentPath.startsWith(this.rootPath) && currentPath.length >= this.rootPath.length) {
+            for (const fileName of this.config.ignoreFileNames) {
+                const ignoreFilePath = path.join(currentPath, fileName);
+                // 避免重复加载
+                if (!this.ignoreFiles.has(ignoreFilePath)) {
+                    this.loadIgnoreFile(ignoreFilePath);
+                }
+            }
+            // 向上一级目录
+            const parentPath = path.dirname(currentPath);
+            if (parentPath === currentPath)
+                break; // 已到达根目录
+            currentPath = parentPath;
+        }
+    }
+    /**
+     * 检查单个规则是否匹配目标路径
+     */
+    matchRule(rule, targetPath, isDirectory) {
+        const relativePath = path.relative(rule.basePath, targetPath);
+        if (rule.isAbsolute) {
+            const patternWithoutSlash = rule.pattern.replace(/^\//, '');
+            if (relativePath === patternWithoutSlash ||
+                relativePath.startsWith(patternWithoutSlash + path.sep)) {
+                return true;
+            }
+            return minimatch(relativePath, patternWithoutSlash, { dot: true });
+        }
+        if (!rule.pattern.includes('/')) {
+            const basename = path.basename(targetPath);
+            if (rule.isDirectory) {
+                if (minimatch(basename, rule.pattern, { dot: true })) {
+                    return true;
+                }
+                const parts = relativePath.split(path.sep);
+                for (let i = 0; i < parts.length; i++) {
+                    if (minimatch(parts[i], rule.pattern, { dot: true })) {
+                        return true;
+                    }
+                }
+            }
+            else {
+                if (minimatch(basename, rule.pattern, { dot: true })) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        return minimatch(relativePath, rule.pattern, { dot: true });
+    }
+    /**
+     * 检查路径是否被忽略
+     * 返回 true 表示应该忽略，false 表示不忽略
+     */
+    isIgnored(targetPath, isDirectory = false) {
+        const absolutePath = path.resolve(targetPath);
+        // 确保路径在 root 内
+        if (!absolutePath.startsWith(this.rootPath))
+            return false;
+        // 就近查找并加载 .ignore 文件
+        this.findAndLoadIgnoreFiles(absolutePath);
+        // 收集所有相关规则（按优先级排序）
+        // 规则优先级：就近的 .ignore 文件 > 上层的 .ignore 文件 > 全局配置
+        const allRules = [];
+        // 1. 添加全局规则（最低优先级）
+        allRules.push(...this.globalRules);
+        // 2. 添加 .ignore 文件规则（按目录层级从根到当前）
+        const sortedIgnoreFiles = Array.from(this.ignoreFiles.values())
+            .sort((a, b) => {
+            // 按 basePath 深度排序：根目录优先级低，近目录优先级高
+            const depthA = a.basePath.split(path.sep).length;
+            const depthB = b.basePath.split(path.sep).length;
+            return depthA - depthB;
+        });
+        for (const ignoreFile of sortedIgnoreFiles) {
+            // 只考虑影响当前路径的规则文件
+            if (absolutePath.startsWith(ignoreFile.basePath)) {
+                allRules.push(...ignoreFile.rules);
+            }
+        }
+        // 3. 应用规则（后出现的规则优先级更高）
+        let shouldIgnore = false;
+        for (const rule of allRules) {
+            if (this.matchRule(rule, absolutePath, isDirectory)) {
+                // 否定规则取消忽略
+                if (rule.isNegation) {
+                    shouldIgnore = false;
+                }
+                else {
+                    shouldIgnore = true;
+                }
+            }
+        }
+        return shouldIgnore;
+    }
+    /**
+     * 清除缓存的 .ignore 文件（用于重新加载）
+     */
+    clearCache() {
+        this.ignoreFiles.clear();
+    }
+    updateGlobalPatterns(patterns) {
+        this.globalRules = this.parsePatterns(patterns, this.rootPath);
+    }
+    /**
+     * 获取已加载的 .ignore 文件列表
+     */
+    getLoadedIgnoreFiles() {
+        return Array.from(this.ignoreFiles.keys());
+    }
+}

package/dist/server/index.js

@@ -0,0 +1,116 @@
+import { serve } from '@hono/node-server';
+import { Hono } from 'hono';
+import { cors } from 'hono/cors';
+import { createFileRouter } from './api.js';
+import { loadConfig, DEFAULT_PORT, DEFAULT_HOST } from '../config.js';
+import { setupWatcher } from './watcher.js';
+import { IgnoreMatcher } from './ignore.js';
+import { WebSocketServer, WebSocket } from 'ws';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const clientDir = path.join(__dirname, '..', 'client');
+function findRootForPath(filePath, config) {
+    for (const root of config.roots) {
+        if (filePath.startsWith(root.path)) {
+            return root.path;
+        }
+    }
+    return config.roots[0]?.path || '';
+}
+async function main() {
+    const config = await loadConfig();
+    const matcher = new IgnoreMatcher(config.roots[0]?.path || process.cwd(), {
+        enableIgnoreFiles: config.ignore.enableIgnoreFiles,
+        ignoreFileNames: config.ignore.ignoreFileNames,
+        globalPatterns: config.ignore.patterns,
+    });
+    const app = new Hono();
+    app.use('*', cors());
+    const fileRouter = createFileRouter(config, matcher);
+    app.route('/api/files', fileRouter);
+    app.get('/assets/*', async (c) => {
+        const filePath = c.req.path.replace('/assets', '');
+        const fullPath = path.join(clientDir, 'assets', filePath);
+        try {
+            const content = fs.readFileSync(fullPath);
+            const ext = path.extname(filePath);
+            const contentType = ext === '.js' ? 'application/javascript' : ext === '.css' ? 'text/css' : 'text/plain';
+            return new Response(content, { headers: { 'Content-Type': contentType } });
+        }
+        catch {
+            return c.notFound();
+        }
+    });
+    app.get('/logo.png', async (c) => {
+        const fullPath = path.join(clientDir, 'logo.png');
+        try {
+            const content = fs.readFileSync(fullPath);
+            return new Response(content, { headers: { 'Content-Type': 'image/png' } });
+        }
+        catch {
+            return c.notFound();
+        }
+    });
+    app.get('/favicon.ico', async (c) => {
+        const fullPath = path.join(clientDir, 'favicon.ico');
+        try {
+            const content = fs.readFileSync(fullPath);
+            return new Response(content, { headers: { 'Content-Type': 'image/x-icon' } });
+        }
+        catch {
+            return c.notFound();
+        }
+    });
+    app.get('*', async (c) => {
+        const indexPath = path.join(clientDir, 'index.html');
+        try {
+            const content = fs.readFileSync(indexPath, 'utf-8');
+            return new Response(content, {
+                headers: { 'Content-Type': 'text/html' },
+            });
+        }
+        catch {
+            return c.notFound();
+        }
+    });
+    const server = serve({
+        fetch: app.fetch,
+        port: DEFAULT_PORT,
+        hostname: DEFAULT_HOST,
+    });
+    const clients = new Set();
+    const wss = new WebSocketServer({ noServer: true });
+    wss.on('connection', (ws) => {
+        clients.add(ws);
+        ws.on('close', () => clients.delete(ws));
+    });
+    server.on('upgrade', (request, socket, head) => {
+        if (request.url === '/ws') {
+            wss.handleUpgrade(request, socket, head, (ws) => {
+                wss.emit('connection', ws, request);
+            });
+        }
+    });
+    setupWatcher(config, matcher, {
+        onFileChange: (rootPath, event, filePath) => {
+            const actualRootPath = findRootForPath(filePath, config);
+            const relativePath = filePath.replace(actualRootPath, '');
+            const message = JSON.stringify({ type: 'file:change', event, path: relativePath, rootPath: actualRootPath });
+            clients.forEach((client) => {
+                if (client.readyState === WebSocket.OPEN) {
+                    client.send(message);
+                }
+            });
+        },
+    });
+    console.log(`\n  ColonyNote is running!\n`);
+    console.log(`  Local:   http://localhost:${DEFAULT_PORT}`);
+    console.log(`  Network: http://${DEFAULT_HOST}:${DEFAULT_PORT}`);
+    console.log(`  Roots:   ${config.roots.map(r => r.path).join(', ')}\n`);
+}
+main().catch((e) => {
+    console.error('Failed to start:', e);
+    process.exit(1);
+});

package/dist/server/watcher.js

@@ -0,0 +1,62 @@
+import chokidar from 'chokidar';
+import fs from 'fs';
+export function setupWatcher(config, matcher, callbacks) {
+    const rootPaths = config.roots.map(r => r.path);
+    const watcher = chokidar.watch(rootPaths, {
+        ignored: (filePath) => {
+            if (!config.showHiddenFiles && (filePath.includes('/.') || filePath.startsWith('.')))
+                return true;
+            try {
+                const stat = fs.statSync(filePath);
+                if (matcher.isIgnored(filePath, stat.isDirectory()))
+                    return true;
+            }
+            catch {
+                if (matcher.isIgnored(filePath, false))
+                    return true;
+            }
+            const ext = filePath.split('.').pop()?.toLowerCase() || '';
+            if (ext && !config.allowedExtensions.includes('.' + ext) && !filePath.includes('/')) {
+                return false;
+            }
+            return false;
+        },
+        persistent: true,
+        ignoreInitial: true,
+        depth: 3,
+    });
+    watcher
+        .on('add', (path) => {
+        if (config.allowedExtensions.some(ext => path.endsWith(ext))) {
+            const matchingRoot = config.roots.find(r => path.startsWith(r.path));
+            const rootPath = matchingRoot?.path || config.roots[0]?.path || '';
+            callbacks.onFileChange(rootPath, 'add', path);
+        }
+    })
+        .on('change', (path) => {
+        if (config.allowedExtensions.some(ext => path.endsWith(ext))) {
+            const matchingRoot = config.roots.find(r => path.startsWith(r.path));
+            const rootPath = matchingRoot?.path || config.roots[0]?.path || '';
+            callbacks.onFileChange(rootPath, 'change', path);
+        }
+    })
+        .on('unlink', (path) => {
+        if (config.allowedExtensions.some(ext => path.endsWith(ext))) {
+            const matchingRoot = config.roots.find(r => path.startsWith(r.path));
+            const rootPath = matchingRoot?.path || config.roots[0]?.path || '';
+            callbacks.onFileChange(rootPath, 'unlink', path);
+        }
+    })
+        .on('addDir', (path) => {
+        const matchingRoot = config.roots.find(r => path.startsWith(r.path));
+        const rootPath = matchingRoot?.path || config.roots[0]?.path || '';
+        callbacks.onFileChange(rootPath, 'addDir', path);
+    })
+        .on('unlinkDir', (path) => {
+        const matchingRoot = config.roots.find(r => path.startsWith(r.path));
+        const rootPath = matchingRoot?.path || config.roots[0]?.path || '';
+        callbacks.onFileChange(rootPath, 'unlinkDir', path);
+    })
+        .on('error', (error) => console.error('Watcher error:', error));
+    return watcher;
+}

package/package.json

@@ -1,13 +1,108 @@
 {
   "name": "colonynote",
-  "version": "0.0.0",
-  "description": "",
-  "main": "index.js",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+  "version": "1.0.0-beta.12",
+  "engines": {
+    "node": ">=18"
+  },
+  "sideEffects": false,
+  "description": "Markdown online editor with real-time preview and LaTeX support",
+  "keywords": [
+    "markdown",
+    "editor",
+    "latex",
+    "real-time",
+    "cli",
+    "document"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT",
+  "author": "岳晓亮 <hi@yuexiaoliang.com>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/opencolony/note.git"
+  },
+  "type": "module",
+  "bin": {
+    "colonynote": "./bin/colonynote.js"
   },
-  "keywords": [],
-  "author": "",
-  "license": "ISC",
-  "packageManager": "pnpm@10.32.1"
-}
+  "files": [
+    "bin",
+    "dist"
+  ],
+  "dependencies": {
+    "@hono/node-server": "^1.19.11",
+    "@milkdown/crepe": "^7.19.2",
+    "@milkdown/plugin-listener": "^7.19.2",
+    "@milkdown/prose": "^7.19.2",
+    "@milkdown/react": "^7.19.2",
+    "@milkdown/utils": "^7.19.2",
+    "@radix-ui/react-alert-dialog": "^1.1.15",
+    "@radix-ui/react-collapsible": "^1.1.12",
+    "@radix-ui/react-dialog": "^1.1.15",
+    "@radix-ui/react-popover": "^1.1.15",
+    "@radix-ui/react-scroll-area": "^1.2.10",
+    "@radix-ui/react-slot": "^1.2.4",
+    "@tailwindcss/typography": "^0.5.19",
+    "@tailwindcss/vite": "^4.2.2",
+    "@tiptap/extension-code-block-lowlight": "^3.20.4",
+    "@tiptap/extension-highlight": "^3.20.4",
+    "@tiptap/extension-image": "^3.20.4",
+    "@tiptap/extension-link": "^3.20.4",
+    "@tiptap/extension-placeholder": "^3.20.4",
+    "@tiptap/extension-table": "^3.20.4",
+    "@tiptap/extension-table-cell": "^3.20.4",
+    "@tiptap/extension-table-header": "^3.20.4",
+    "@tiptap/extension-table-row": "^3.20.4",
+    "@tiptap/extension-task-item": "^3.20.4",
+    "@tiptap/extension-task-list": "^3.20.4",
+    "@tiptap/extension-typography": "^3.20.4",
+    "@tiptap/extension-underline": "^3.20.4",
+    "@tiptap/pm": "^3.20.4",
+    "@tiptap/react": "^3.20.4",
+    "@tiptap/starter-kit": "^3.20.4",
+    "chokidar": "^4.0.3",
+    "class-variance-authority": "^0.7.1",
+    "clsx": "^2.1.1",
+    "cmdk": "^1.1.1",
+    "colonynote": "1.0.0-beta.10",
+    "commander": "^14.0.3",
+    "flexsearch": "^0.8.212",
+    "hono": "^4.12.9",
+    "katex": "^0.16.40",
+    "lowlight": "^3.3.0",
+    "lucide-react": "^0.577.0",
+    "markdown-extensions": "^2.0.0",
+    "mermaid": "^11.13.0",
+    "minimatch": "^10.2.5",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
+    "react-zoom-pan-pinch": "^3.7.0",
+    "tailwind-merge": "^3.5.0",
+    "tailwindcss": "^4.2.2",
+    "tiptap-markdown": "^0.9.0",
+    "ws": "^8.20.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.19.15",
+    "@types/react": "^18.3.28",
+    "@types/react-dom": "^18.3.7",
+    "@types/ws": "^8.18.1",
+    "@vitejs/plugin-react": "^4.7.0",
+    "bumpp": "^11.0.1",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3",
+    "vite": "^6.4.1"
+  },
+  "scripts": {
+    "dev": "tsx src/dev.ts",
+    "dev:frontend": "vite",
+    "dev:backend": "tsx src/server/index.ts",
+    "build": "vite build && tsc -p tsconfig.server.json",
+    "preview": "vite preview",
+    "start": "node dist/server/index.js",
+    "typecheck": "tsc --noEmit",
+    "release": "bumpp"
+  }
+}

package/index.js

@@ -1 +0,0 @@
-console.log('hello')