meno-core 1.0.53 → 1.1.0

package/lib/server/middleware/logger.ts

@@ -18,38 +18,31 @@ const DEFAULT_OPTIONS: LogOptions = {
 /**
  * Log a request
  */
-export function logRequest(
-  req: Request,
-  options: LogOptions = {}
-): void {
+export function logRequest(req: Request, options: LogOptions = {}): void {
   const opts = { ...DEFAULT_OPTIONS, ...options };
-  
+
   if (!opts.logRequests) {
     return;
   }
 
-  const url = new URL(req.url);
-  const timestamp = new Date().toISOString();
+  const _url = new URL(req.url);
+  const _timestamp = new Date().toISOString();
 }
 
 /**
  * Log an error
  */
-export function logError(
-  error: unknown,
-  context?: string,
-  options: LogOptions = {}
-): void {
+export function logError(error: unknown, context?: string, options: LogOptions = {}): void {
   const opts = { ...DEFAULT_OPTIONS, ...options };
-  
+
   if (!opts.logErrors) {
     return;
   }
 
-  const timestamp = new Date().toISOString();
-  const contextStr = context ? ` [${context}]` : '';
-  const errorMessage = error instanceof Error ? error.message : String(error);
-  
+  const _timestamp = new Date().toISOString();
+  const _contextStr = context ? ` [${context}]` : '';
+  const _errorMessage = error instanceof Error ? error.message : String(error);
+
   if (error instanceof Error && error.stack) {
   }
 }
@@ -57,19 +50,15 @@ export function logError(
 /**
  * Log response time
  */
-export function logResponseTime(
-  startTime: number,
-  req: Request,
-  options: LogOptions = {}
-): void {
+export function logResponseTime(startTime: number, req: Request, options: LogOptions = {}): void {
   const opts = { ...DEFAULT_OPTIONS, ...options };
-  
+
   if (!opts.logResponseTime) {
     return;
   }
 
-  const url = new URL(req.url);
-  const duration = Date.now() - startTime;
+  const _url = new URL(req.url);
+  const _duration = Date.now() - startTime;
 }
 
 /**
@@ -77,14 +66,14 @@ export function logResponseTime(
  */
 export function withLogging<T extends unknown[]>(
   handler: (...args: T) => Promise<Response>,
-  options: LogOptions = {}
+  options: LogOptions = {},
 ): (...args: T) => Promise<Response> {
   return async (...args: T) => {
     const startTime = Date.now();
     const req = args[0] as Request;
-    
+
     logRequest(req, options);
-    
+
     try {
       const response = await handler(...args);
       logResponseTime(startTime, req, options);
@@ -96,4 +85,3 @@ export function withLogging<T extends unknown[]>(
     }
   };
 }
-

package/lib/server/migrateTemplates.ts

@@ -1,6 +1,6 @@
-import { existsSync } from 'fs';
-import { rename } from 'fs/promises';
-import { join } from 'path';
+import { existsSync } from 'node:fs';
+import { rename } from 'node:fs/promises';
+import { join } from 'node:path';
 import { projectPaths } from './projectContext';
 
 /**

package/lib/server/pageCache.test.ts

@@ -1,167 +1,166 @@
-import { test, expect, describe, beforeEach } from "bun:test";
-import { PageCache } from "./pageCache";
-import type { LineMap } from "./utils/jsonLineMapper";
+import { test, expect, describe, beforeEach } from 'bun:test';
+import { PageCache } from './pageCache';
+import type { LineMap } from './utils/jsonLineMapper';
 
 // Helper to create empty line map for tests
 const emptyLineMap = (): LineMap => new Map();
 
-describe("PageCache", () => {
+describe('PageCache', () => {
   let cache: PageCache;
 
   beforeEach(() => {
     cache = new PageCache();
   });
 
-  describe("set and get", () => {
-    test("should store and retrieve page content", () => {
-      cache.set("/", "home content", emptyLineMap());
-      const result = cache.getContent("/");
+  describe('set and get', () => {
+    test('should store and retrieve page content', () => {
+      cache.set('/', 'home content', emptyLineMap());
+      const result = cache.getContent('/');
 
-      expect(result).toBe("home content");
+      expect(result).toBe('home content');
     });
 
-    test("should return undefined for non-existent page", () => {
-      const result = cache.getContent("/nonexistent");
+    test('should return undefined for non-existent page', () => {
+      const result = cache.getContent('/nonexistent');
       expect(result).toBeUndefined();
     });
 
-    test("should overwrite existing page content", () => {
-      cache.set("/about", "old content", emptyLineMap());
-      cache.set("/about", "new content", emptyLineMap());
+    test('should overwrite existing page content', () => {
+      cache.set('/about', 'old content', emptyLineMap());
+      cache.set('/about', 'new content', emptyLineMap());
 
-      const result = cache.getContent("/about");
-      expect(result).toBe("new content");
+      const result = cache.getContent('/about');
+      expect(result).toBe('new content');
     });
   });
 
-  describe("has", () => {
-    test("should return true for cached page", () => {
-      cache.set("/about", "content", emptyLineMap());
-      expect(cache.has("/about")).toBe(true);
+  describe('has', () => {
+    test('should return true for cached page', () => {
+      cache.set('/about', 'content', emptyLineMap());
+      expect(cache.has('/about')).toBe(true);
     });
 
-    test("should return false for non-cached page", () => {
-      expect(cache.has("/nonexistent")).toBe(false);
+    test('should return false for non-cached page', () => {
+      expect(cache.has('/nonexistent')).toBe(false);
     });
   });
 
-  describe("delete", () => {
-    test("should delete cached page", () => {
-      cache.set("/temp", "content", emptyLineMap());
-      expect(cache.has("/temp")).toBe(true);
+  describe('delete', () => {
+    test('should delete cached page', () => {
+      cache.set('/temp', 'content', emptyLineMap());
+      expect(cache.has('/temp')).toBe(true);
 
-      cache.delete("/temp");
-      expect(cache.has("/temp")).toBe(false);
+      cache.delete('/temp');
+      expect(cache.has('/temp')).toBe(false);
     });
 
-    test("should not throw when deleting non-existent page", () => {
-      expect(() => cache.delete("/nonexistent")).not.toThrow();
+    test('should not throw when deleting non-existent page', () => {
+      expect(() => cache.delete('/nonexistent')).not.toThrow();
     });
   });
 
-  describe("keys", () => {
-    test("should return all cached page paths", () => {
-      cache.set("/", "home", emptyLineMap());
-      cache.set("/about", "about", emptyLineMap());
-      cache.set("/contact", "contact", emptyLineMap());
+  describe('keys', () => {
+    test('should return all cached page paths', () => {
+      cache.set('/', 'home', emptyLineMap());
+      cache.set('/about', 'about', emptyLineMap());
+      cache.set('/contact', 'contact', emptyLineMap());
 
       const keys = cache.keys();
 
       expect(keys.length).toBe(3);
-      expect(keys).toContain("/");
-      expect(keys).toContain("/about");
-      expect(keys).toContain("/contact");
+      expect(keys).toContain('/');
+      expect(keys).toContain('/about');
+      expect(keys).toContain('/contact');
     });
 
-    test("should return empty array when cache is empty", () => {
+    test('should return empty array when cache is empty', () => {
       const keys = cache.keys();
       expect(keys).toEqual([]);
     });
   });
 
-  describe("clear", () => {
-    test("should clear all cached pages", () => {
-      cache.set("/", "home", emptyLineMap());
-      cache.set("/about", "about", emptyLineMap());
+  describe('clear', () => {
+    test('should clear all cached pages', () => {
+      cache.set('/', 'home', emptyLineMap());
+      cache.set('/about', 'about', emptyLineMap());
 
       expect(cache.size()).toBe(2);
 
       cache.clear();
 
       expect(cache.size()).toBe(0);
-      expect(cache.has("/")).toBe(false);
-      expect(cache.has("/about")).toBe(false);
+      expect(cache.has('/')).toBe(false);
+      expect(cache.has('/about')).toBe(false);
     });
   });
 
-  describe("size", () => {
-    test("should return number of cached pages", () => {
+  describe('size', () => {
+    test('should return number of cached pages', () => {
       expect(cache.size()).toBe(0);
 
-      cache.set("/", "home", emptyLineMap());
+      cache.set('/', 'home', emptyLineMap());
       expect(cache.size()).toBe(1);
 
-      cache.set("/about", "about", emptyLineMap());
+      cache.set('/about', 'about', emptyLineMap());
       expect(cache.size()).toBe(2);
 
-      cache.delete("/");
+      cache.delete('/');
       expect(cache.size()).toBe(1);
     });
   });
 
-  describe("toObject", () => {
-    test("should convert cache to object", () => {
-      cache.set("/", "home content", emptyLineMap());
-      cache.set("/about", "about content", emptyLineMap());
+  describe('toObject', () => {
+    test('should convert cache to object', () => {
+      cache.set('/', 'home content', emptyLineMap());
+      cache.set('/about', 'about content', emptyLineMap());
 
       const obj = cache.toObject();
 
-      expect(obj["/"]).toBe("home content");
-      expect(obj["/about"]).toBe("about content");
+      expect(obj['/']).toBe('home content');
+      expect(obj['/about']).toBe('about content');
       expect(Object.keys(obj).length).toBe(2);
     });
 
-    test("should return empty object when cache is empty", () => {
+    test('should return empty object when cache is empty', () => {
       const obj = cache.toObject();
       expect(obj).toEqual({});
     });
   });
 
-  describe("page path mapping", () => {
-    test("should handle index page as root path", () => {
-      cache.set("/", "home content", emptyLineMap());
-      expect(cache.getContent("/")).toBe("home content");
+  describe('page path mapping', () => {
+    test('should handle index page as root path', () => {
+      cache.set('/', 'home content', emptyLineMap());
+      expect(cache.getContent('/')).toBe('home content');
     });
 
-    test("should handle nested paths", () => {
-      cache.set("/blog/post-1", "blog post content", emptyLineMap());
-      expect(cache.getContent("/blog/post-1")).toBe("blog post content");
+    test('should handle nested paths', () => {
+      cache.set('/blog/post-1', 'blog post content', emptyLineMap());
+      expect(cache.getContent('/blog/post-1')).toBe('blog post content');
     });
   });
 
-  describe("line map", () => {
-    test("should store and retrieve line map", () => {
+  describe('line map', () => {
+    test('should store and retrieve line map', () => {
       const lineMap: LineMap = new Map();
-      lineMap.set("0", { startLine: 31, endLine: 39 });
-      lineMap.set("1", { startLine: 40, endLine: 100 });
+      lineMap.set('0', { startLine: 31, endLine: 39 });
+      lineMap.set('1', { startLine: 40, endLine: 100 });
 
-      cache.set("/", "home content", lineMap);
-      const result = cache.getLineMap("/");
+      cache.set('/', 'home content', lineMap);
+      const result = cache.getLineMap('/');
 
       expect(result).toBeDefined();
-      expect(result?.get("0")).toEqual({ startLine: 31, endLine: 39 });
-      expect(result?.get("1")).toEqual({ startLine: 40, endLine: 100 });
+      expect(result?.get('0')).toEqual({ startLine: 31, endLine: 39 });
+      expect(result?.get('1')).toEqual({ startLine: 40, endLine: 100 });
     });
 
-    test("should get line range for specific element path", () => {
+    test('should get line range for specific element path', () => {
       const lineMap: LineMap = new Map();
-      lineMap.set("0,1", { startLine: 50, endLine: 75 });
+      lineMap.set('0,1', { startLine: 50, endLine: 75 });
 
-      cache.set("/about", "about content", lineMap);
-      const range = cache.getLineRange("/about", "0,1");
+      cache.set('/about', 'about content', lineMap);
+      const range = cache.getLineRange('/about', '0,1');
 
       expect(range).toEqual({ startLine: 50, endLine: 75 });
     });
   });
 });
-

package/lib/server/pageCache.ts

@@ -94,4 +94,3 @@ export class PageCache {
     return obj;
   }
 }
-

package/lib/server/projectContext.ts

@@ -1,12 +1,11 @@
-import { join, dirname } from 'path';
+import { join, dirname } from 'node:path';
 import { getModuleDir } from './runtime';
 
 let projectRoot: string = process.cwd();
 
 // Package root is where the editor files are installed (2 levels up from this file)
 // In packaged Electron builds, MENO_CORE_ROOT overrides import.meta.url resolution
-const packageRoot = process.env.MENO_CORE_ROOT
-  || join(dirname(getModuleDir(import.meta.url)), '..');
+const packageRoot = process.env.MENO_CORE_ROOT || join(dirname(getModuleDir(import.meta.url)), '..');
 
 export function setProjectRoot(root: string): void {
   projectRoot = root;
@@ -40,7 +39,9 @@ export const projectPaths = {
   enums: () => join(projectRoot, 'enums.json'),
   dist: () => join(projectRoot, 'dist'),
   env: () => join(projectRoot, '.env'),
-  get project() { return projectRoot; }, // Direct access to project root
+  get project() {
+    return projectRoot;
+  }, // Direct access to project root
 };
 
 // Path getters for package files (core assets)