npm - zephyr-astro-integration - Versions diffs - 0.0.0-canary.7 → 0.0.0-canary.8 - Mend

zephyr-astro-integration 0.0.0-canary.7 → 0.0.0-canary.8

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (16) hide show

package/package.json +2 -2
package/.eslintrc.json +0 -20
package/dist/tsconfig.tsbuildinfo +0 -1
package/jest.config.ts +0 -11
package/project.json +0 -37
package/src/__test__/integration.spec.ts +0 -19
package/src/index.ts +0 -2
package/src/lib/__test__/astro-integration-zephyr.spec.ts +0 -242
package/src/lib/astro-integration-zephyr.ts +0 -63
package/src/lib/internal/__test__/extract-astro-assets-from-build-hook.spec.ts +0 -269
package/src/lib/internal/__test__/extract-astro-assets-map.spec.ts +0 -316
package/src/lib/internal/__test__/file-type-detection.spec.ts +0 -108
package/src/lib/internal/extract-astro-assets-map.ts +0 -275
package/tsconfig.json +0 -23
package/tsconfig.lib.json +0 -11
package/tsconfig.spec.json +0 -14

package/src/lib/internal/__test__/extract-astro-assets-map.spec.ts DELETED Viewed

@@ -1,316 +0,0 @@
-import { mkdir, readFile, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { extractAstroAssetsMap } from '../extract-astro-assets-map';
-const buildAssetsMapMock = jest.fn();
-const logFnMock = jest.fn();
-// Mock the zephyr-agent buildAssetsMap function
-jest.mock('zephyr-agent', () => ({
-  buildAssetsMap: (...args: unknown[]) => buildAssetsMapMock(...args),
-  logFn: (...args: unknown[]) => logFnMock(...args),
-}));
-describe('extractAstroAssetsMap', () => {
-  let tempDir: string;
-  beforeEach(async () => {
-    tempDir = join(tmpdir(), `astro-test-${Date.now()}`);
-    await mkdir(tempDir, { recursive: true });
-    buildAssetsMapMock.mockImplementation((assets) => {
-      const result: Record<string, unknown> = {};
-      Object.keys(assets).forEach((key, index) => {
-        const hash = `hash${index + 1}`;
-        result[hash] = {
-          hash,
-          content: assets[key].content,
-          type: assets[key].type,
-          filepath: key,
-        };
-      });
-      return result;
-    });
-  });
-  afterEach(async () => {
-    try {
-      await rm(tempDir, { recursive: true, force: true });
-    } catch {
-      // Ignore cleanup errors
-    }
-    if (logFnMock && typeof logFnMock.mockRestore === 'function') {
-      logFnMock.mockRestore();
-    }
-    jest.clearAllMocks();
-  });
-  describe('Basic Asset Extraction', () => {
-    it('should extract assets from build directory', async () => {
-      // Create test files
-      await writeFile(join(tempDir, 'index.html'), '<html><body>Hello</body></html>');
-      await writeFile(join(tempDir, 'style.css'), 'body { color: red; }');
-      await writeFile(join(tempDir, 'script.js'), 'console.log("hello");');
-      const assetsMap = await extractAstroAssetsMap(tempDir);
-      expect(Object.keys(assetsMap)).toHaveLength(3);
-      expect(buildAssetsMapMock).toHaveBeenCalledWith(
-        expect.objectContaining({
-          'index.html': expect.objectContaining({
-            content: expect.any(Buffer),
-            type: 'text/html',
-          }),
-          'style.css': expect.objectContaining({
-            content: expect.any(Buffer),
-            type: 'text/css',
-          }),
-          'script.js': expect.objectContaining({
-            content: expect.any(Buffer),
-            type: 'application/javascript',
-          }),
-        }),
-        expect.any(Function),
-        expect.any(Function)
-      );
-    });
-    it('should handle empty directory', async () => {
-      const assetsMap = await extractAstroAssetsMap(tempDir);
-      expect(Object.keys(assetsMap)).toHaveLength(0);
-      expect(buildAssetsMapMock).toHaveBeenCalledWith(
-        {},
-        expect.any(Function),
-        expect.any(Function)
-      );
-    });
-  });
-  describe('File Filtering', () => {
-    it('should skip source maps', async () => {
-      await writeFile(join(tempDir, 'index.html'), '<html></html>');
-      await writeFile(join(tempDir, 'style.css.map'), '{"version":3}');
-      await writeFile(join(tempDir, 'script.js.map'), '{"version":3}');
-      const result = await extractAstroAssetsMap(tempDir);
-      expect(result).toBeDefined();
-      expect(buildAssetsMapMock).toHaveBeenCalledWith(
-        expect.objectContaining({
-          'index.html': expect.any(Object),
-        }),
-        expect.any(Function),
-        expect.any(Function)
-      );
-      expect(buildAssetsMapMock).not.toHaveBeenCalledWith(
-        expect.objectContaining({
-          'style.css.map': expect.any(Object),
-          'script.js.map': expect.any(Object),
-        }),
-        expect.any(Function),
-        expect.any(Function)
-      );
-    });
-    it('should skip system files', async () => {
-      await writeFile(join(tempDir, 'index.html'), '<html></html>');
-      await writeFile(join(tempDir, '.DS_Store'), 'system data');
-      await writeFile(join(tempDir, 'Thumbs.db'), 'windows thumbnail');
-      const result = await extractAstroAssetsMap(tempDir);
-      expect(result).toBeDefined();
-      expect(buildAssetsMapMock).toHaveBeenCalledWith(
-        expect.objectContaining({
-          'index.html': expect.any(Object),
-        }),
-        expect.any(Function),
-        expect.any(Function)
-      );
-    });
-    it('should skip node_modules and git directories', async () => {
-      await mkdir(join(tempDir, 'node_modules'), { recursive: true });
-      await mkdir(join(tempDir, '.git'), { recursive: true });
-      await writeFile(join(tempDir, 'node_modules', 'package.json'), '{}');
-      await writeFile(join(tempDir, '.git', 'config'), 'git config');
-      await writeFile(join(tempDir, 'index.html'), '<html></html>');
-      const result = await extractAstroAssetsMap(tempDir);
-      expect(result).toBeDefined();
-      expect(buildAssetsMapMock).toHaveBeenCalledWith(
-        expect.objectContaining({
-          'index.html': expect.any(Object),
-        }),
-        expect.any(Function),
-        expect.any(Function)
-      );
-    });
-  });
-  describe('File Type Detection', () => {
-    it('should correctly identify file types', async () => {
-      const testFiles = [
-        ['index.html', '<html></html>', 'text/html'],
-        ['style.css', 'body {}', 'text/css'],
-        ['script.js', 'console.log()', 'application/javascript'],
-        ['module.mjs', 'export default {}', 'application/javascript'],
-        ['data.json', '{}', 'application/json'],
-        ['image.png', Buffer.from('PNG data'), 'image/png'],
-        ['image.jpg', Buffer.from('JPG data'), 'image/jpeg'],
-        ['image.svg', '<svg></svg>', 'image/svg+xml'],
-        ['favicon.ico', Buffer.from('ICO data'), 'image/x-icon'],
-        ['font.woff', Buffer.from('WOFF data'), 'font/woff'],
-        ['font.woff2', Buffer.from('WOFF2 data'), 'font/woff2'],
-        ['unknown.xyz', 'unknown content', 'application/octet-stream'],
-      ];
-      for (const [filename, content] of testFiles) {
-        await writeFile(join(tempDir, filename.toString()), content);
-      }
-      await extractAstroAssetsMap(tempDir);
-      const buildAssetsMapCall = (buildAssetsMapMock as jest.Mock).mock.calls[0];
-      const assets = buildAssetsMapCall[0];
-      testFiles.forEach(([filename, , expectedType]) => {
-        expect(assets[filename.toString()]).toHaveProperty('type', expectedType);
-      });
-    });
-  });
-  describe('Directory Traversal', () => {
-    it('should handle nested directories', async () => {
-      await mkdir(join(tempDir, 'assets', 'js'), { recursive: true });
-      await mkdir(join(tempDir, 'assets', 'css'), { recursive: true });
-      await mkdir(join(tempDir, 'images'), { recursive: true });
-      await writeFile(join(tempDir, 'index.html'), '<html></html>');
-      await writeFile(join(tempDir, 'assets', 'js', 'main.js'), 'console.log()');
-      await writeFile(join(tempDir, 'assets', 'css', 'style.css'), 'body {}');
-      await writeFile(join(tempDir, 'images', 'logo.png'), 'PNG data');
-      const result = await extractAstroAssetsMap(tempDir);
-      expect(result).toBeDefined();
-      expect(buildAssetsMapMock).toHaveBeenCalledWith(
-        expect.objectContaining({
-          'index.html': expect.any(Object),
-          'assets/js/main.js': expect.any(Object),
-          'assets/css/style.css': expect.any(Object),
-          'images/logo.png': expect.any(Object),
-        }),
-        expect.any(Function),
-        expect.any(Function)
-      );
-    });
-    it('should handle deeply nested directories', async () => {
-      const deepPath = join(tempDir, 'a', 'b', 'c', 'd', 'e');
-      await mkdir(deepPath, { recursive: true });
-      await writeFile(join(deepPath, 'deep.txt'), 'deep file');
-      const result = await extractAstroAssetsMap(tempDir);
-      expect(result).toBeDefined();
-      expect(buildAssetsMapMock).toHaveBeenCalledWith(
-        expect.objectContaining({
-          'a/b/c/d/e/deep.txt': expect.objectContaining({
-            type: 'text/plain',
-          }),
-        }),
-        expect.any(Function),
-        expect.any(Function)
-      );
-    });
-  });
-  describe('Error Handling', () => {
-    it('should handle file read errors gracefully', async () => {
-      await writeFile(join(tempDir, 'good.txt'), 'readable');
-      await writeFile(join(tempDir, 'index.html'), '<html></html>');
-      // Mock readFile to fail for specific file
-      const originalReadFile = readFile;
-      jest
-        .spyOn(require('node:fs/promises'), 'readFile')
-        .mockImplementation(async (path: any) => {
-          if (path.toString().includes('good.txt')) {
-            throw new Error('Permission denied');
-          }
-          return originalReadFile(path);
-        });
-      const result = await extractAstroAssetsMap(tempDir);
-      expect(result).toBeDefined();
-      expect(logFnMock).toHaveBeenCalledWith(
-        'warn',
-        expect.stringMatching(/Failed to read file.*good\.txt/)
-      );
-      // Should still process the readable file
-      expect(buildAssetsMapMock).toHaveBeenCalledWith(
-        expect.objectContaining({
-          'index.html': expect.any(Object),
-        }),
-        expect.any(Function),
-        expect.any(Function)
-      );
-      jest.restoreAllMocks();
-    });
-    it('should handle directory read errors gracefully', async () => {
-      await writeFile(join(tempDir, 'index.html'), '<html></html>');
-      await mkdir(join(tempDir, 'subdir'), { recursive: true });
-      // Mock readdir to fail for subdirectory
-      const originalReaddir = require('node:fs/promises').readdir;
-      jest
-        .spyOn(require('node:fs/promises'), 'readdir')
-        .mockImplementation(async (path: any, options) => {
-          if (path.toString().includes('subdir')) {
-            throw new Error('Access denied');
-          }
-          return originalReaddir(path, options);
-        });
-      const result = await extractAstroAssetsMap(tempDir);
-      expect(result).toBeDefined();
-      expect(logFnMock).toHaveBeenCalledWith(
-        'warn',
-        expect.stringMatching(/Failed to walk directory.*subdir/)
-      );
-      jest.restoreAllMocks();
-    });
-  });
-  describe('Utility Functions', () => {
-    it('should test extractBuffer function', async () => {
-      await writeFile(join(tempDir, 'test.txt'), 'test content');
-      await extractAstroAssetsMap(tempDir);
-      const extractBuffer = (buildAssetsMapMock as jest.Mock).mock.calls[0][1];
-      const testAsset = { content: Buffer.from('test'), type: 'text/plain' };
-      expect(extractBuffer(testAsset)).toBe(testAsset.content);
-    });
-    it('should test getAssetType function', async () => {
-      await writeFile(join(tempDir, 'test.txt'), 'test content');
-      await extractAstroAssetsMap(tempDir);
-      const getAssetType = (buildAssetsMapMock as jest.Mock).mock.calls[0][2];
-      const testAsset = { content: Buffer.from('test'), type: 'text/plain' };
-      expect(getAssetType(testAsset)).toBe('text/plain');
-    });
-  });
-});

package/src/lib/internal/__test__/file-type-detection.spec.ts DELETED Viewed

@@ -1,108 +0,0 @@
-// Separate test file for detailed file type detection testing
-// This tests the getFileType logic without requiring file system operations
-// We need to extract the getFileType function for direct testing
-// Let's test it by examining the behavior through extractAstroAssetsMap
-import { extractAstroAssetsMap } from '../extract-astro-assets-map';
-import { buildAssetsMap } from 'zephyr-agent';
-import { mkdir, writeFile, rm } from 'node:fs/promises';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-jest.mock('zephyr-agent', () => ({
-  buildAssetsMap: jest.fn(),
-}));
-describe('File Type Detection', () => {
-  let tempDir: string;
-  beforeEach(async () => {
-    tempDir = join(tmpdir(), `file-type-test-${Date.now()}`);
-    await mkdir(tempDir, { recursive: true });
-    (buildAssetsMap as jest.Mock).mockImplementation((assets) => {
-      return Object.fromEntries(
-        Object.entries(assets).map(([key, value], index) => [
-          `hash${index}`,
-          { filepath: key, ...(value as Record<string, unknown>) },
-        ])
-      );
-    });
-  });
-  afterEach(async () => {
-    try {
-      await rm(tempDir, { recursive: true, force: true });
-    } catch {
-      // Ignore cleanup errors
-    }
-    jest.clearAllMocks();
-  });
-  const testCases = [
-    // Web files
-    ['index.html', 'text/html'],
-    ['INDEX.HTML', 'text/html'], // Case insensitive
-    ['style.css', 'text/css'],
-    ['script.js', 'application/javascript'],
-    ['module.mjs', 'application/javascript'],
-    // Data files
-    ['data.json', 'application/json'],
-    ['config.xml', 'text/xml'],
-    ['readme.txt', 'text/plain'],
-    // Images
-    ['logo.png', 'image/png'],
-    ['photo.jpg', 'image/jpeg'],
-    ['photo.jpeg', 'image/jpeg'],
-    ['animation.gif', 'image/gif'],
-    ['icon.svg', 'image/svg+xml'],
-    ['favicon.ico', 'image/x-icon'],
-    // Fonts
-    ['font.woff', 'font/woff'],
-    ['font.woff2', 'font/woff2'],
-    ['font.ttf', 'font/ttf'],
-    ['font.eot', 'application/vnd.ms-fontobject'],
-    // Unknown/fallback
-    ['unknown.xyz', 'application/octet-stream'],
-    ['no-extension', 'application/octet-stream'],
-    ['file.', 'application/octet-stream'],
-  ];
-  test.each(testCases)('should detect %s as %s', async (filename, expectedType) => {
-    await writeFile(join(tempDir, filename), 'test content');
-    await extractAstroAssetsMap(tempDir);
-    const buildAssetsMapCall = (buildAssetsMap as jest.Mock).mock.calls[0];
-    const assets = buildAssetsMapCall[0];
-    expect(assets[filename]).toHaveProperty('type', expectedType);
-  });
-  it('should handle files with multiple extensions correctly', async () => {
-    const testFiles = [
-      ['script.min.js', 'application/javascript'],
-      ['style.min.css', 'text/css'],
-      ['backup.tar.gz', 'application/octet-stream'], // Should use last extension
-      ['data.test.json', 'application/json'],
-    ];
-    for (const [filename] of testFiles) {
-      await writeFile(join(tempDir, filename), 'content');
-    }
-    await extractAstroAssetsMap(tempDir);
-    const buildAssetsMapCall = (buildAssetsMap as jest.Mock).mock.calls[0];
-    const assets = buildAssetsMapCall[0];
-    testFiles.forEach(([filename, expectedType]) => {
-      expect(assets[filename]).toHaveProperty('type', expectedType);
-    });
-  });
-});

package/src/lib/internal/extract-astro-assets-map.ts DELETED Viewed

@@ -1,275 +0,0 @@
-import { readdir, readFile } from 'node:fs/promises';
-import { join, relative, sep, isAbsolute } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { buildAssetsMap, logFn, type ZeBuildAssetsMap } from 'zephyr-agent';
-interface AstroAsset {
-  content: Buffer | string;
-  type: string;
-}
-function extractBuffer(asset: AstroAsset): Buffer | string | undefined {
-  return asset.content;
-}
-function getAssetType(asset: AstroAsset): string {
-  return asset.type;
-}
-/** Normalize path separators to forward slashes for cross-platform consistency */
-function normalizePath(filePath: string): string {
-  return filePath.split(sep).join('/');
-}
-/** Check if a path looks like a URL route rather than a filesystem path */
-function looksLikeRoute(path: string): boolean {
-  if (!path || !path.startsWith('/')) {
-    return false;
-  }
-  // Dynamic routes have brackets
-  if (path.includes('[') || path.includes(']')) {
-    return true;
-  }
-  // Check if it's a real absolute filesystem path vs a route
-  // Real absolute paths are typically long and contain multiple segments
-  const segments = path.split('/').filter(Boolean);
-  // Paths with just 1-2 segments like /about, /blog, /rss.xml are likely routes
-  // Real filesystem paths like /Users/name/project/file.js have many segments
-  if (segments.length <= 2) {
-    return true;
-  }
-  return false;
-}
-type AstroAssets =
-  | Record<string, unknown>
-  | Map<string, unknown>
-  | Array<unknown>
-  | undefined
-  | null;
-/**
- * Extract assets map from Astro's build hook assets parameter. This is more efficient
- * than walking the filesystem manually.
- */
-export async function extractAstroAssetsFromBuildHook(
-  assets: AstroAssets,
-  outputPath: string
-): Promise<ZeBuildAssetsMap> {
-  const astroAssets: Record<string, AstroAsset> = {};
-  try {
-    // Handle different possible structures of the assets parameter
-    if (!assets) {
-      // Fallback to filesystem walking if assets is not available
-      return await extractAstroAssetsMap(outputPath);
-    }
-    // Assets might be an object, Map, or array depending on Astro version
-    const assetEntries = extractAssetEntries(assets);
-    for (const [filePath, assetInfo] of assetEntries) {
-      try {
-        let fullPath: string | null = null;
-        // Handle URL objects or string paths
-        if (assetInfo && typeof assetInfo === 'object' && 'href' in assetInfo) {
-          // It's a URL object
-          fullPath = fileURLToPath(assetInfo as URL);
-        } else if (typeof assetInfo === 'string' && assetInfo) {
-          // It's a string path - skip if it looks like a route
-          if (looksLikeRoute(assetInfo)) {
-            continue;
-          }
-          // Only treat as absolute if it's really an absolute filesystem path
-          // (not just a route starting with /)
-          fullPath =
-            isAbsolute(assetInfo) && !looksLikeRoute(assetInfo)
-              ? assetInfo // Absolute file system path
-              : join(outputPath, assetInfo); // Relative path or route
-        } else if (typeof filePath === 'string' && filePath) {
-          // Use the key as the file path only if it looks like a file path
-          if (looksLikeRoute(filePath)) {
-            continue;
-          }
-          // Only treat as absolute if it's really an absolute filesystem path
-          fullPath =
-            isAbsolute(filePath) && !looksLikeRoute(filePath)
-              ? filePath // Absolute file system path
-              : join(outputPath, filePath); // Relative path or route
-        }
-        // Skip if we couldn't determine a valid file path
-        if (!fullPath) {
-          continue;
-        }
-        // Skip files we don't want to upload
-        const relativePath = normalizePath(relative(outputPath, fullPath));
-        if (shouldSkipFile(relativePath)) {
-          continue;
-        }
-        // Read the file content
-        const content = await readFile(fullPath);
-        const fileType = getFileType(relativePath);
-        astroAssets[relativePath] = {
-          content,
-          type: fileType,
-        };
-      } catch (readError) {
-        logFn('warn', `Failed to read asset file ${filePath}: ${readError}`);
-        continue;
-      }
-    }
-    // If we didn't find any assets from the hook, fallback to filesystem walking
-    if (Object.keys(astroAssets).length === 0) {
-      return await extractAstroAssetsMap(outputPath);
-    }
-    return buildAssetsMap(astroAssets, extractBuffer, getAssetType);
-  } catch (error) {
-    logFn(
-      'warn',
-      'Error processing assets from Astro build hook:' + JSON.stringify(error, null, 2)
-    );
-    // Fallback to filesystem walking on any error
-    return await extractAstroAssetsMap(outputPath);
-  }
-}
-/**
- * Extract asset entries from the Astro assets parameter. Handles different possible data
- * structures.
- */
-function extractAssetEntries(assets: AstroAssets): [string, unknown][] {
-  const entries: [string, unknown][] = [];
-  if (Array.isArray(assets)) {
-    // Handle array of assets
-    assets.forEach((asset) => {
-      if (typeof asset === 'string') {
-        entries.push([asset, asset]);
-      } else if (asset && typeof asset === 'object') {
-        // Could be an object with path/url properties
-        const assetObj = asset as Record<string, unknown>;
-        const path =
-          assetObj['path'] || assetObj['url'] || assetObj['href'] || assetObj['pathname'];
-        if (path && typeof path === 'string') {
-          entries.push([path, asset]);
-        }
-      }
-    });
-  } else if (assets instanceof Map) {
-    // Handle Map objects
-    for (const [key, value] of assets.entries()) {
-      entries.push([key, value]);
-    }
-  } else if (assets && typeof assets === 'object') {
-    // Handle plain objects
-    for (const [key, value] of Object.entries(assets)) {
-      if (Array.isArray(value)) {
-        // If value is an array, it might contain multiple assets for this route
-        value.forEach((item) => {
-          entries.push([key, item]);
-        });
-      } else {
-        entries.push([key, value]);
-      }
-    }
-  }
-  return entries;
-}
-export async function extractAstroAssetsMap(buildDir: string): Promise<ZeBuildAssetsMap> {
-  const assets: Record<string, AstroAsset> = {};
-  // Recursively walk through the build directory
-  async function walkDir(dirPath: string): Promise<void> {
-    try {
-      const entries = await readdir(dirPath, { withFileTypes: true });
-      for (const entry of entries) {
-        const fullPath = join(dirPath, entry.name);
-        if (entry.isDirectory()) {
-          await walkDir(fullPath);
-        } else if (entry.isFile()) {
-          // Get relative path from build directory
-          const relativePath = normalizePath(relative(buildDir, fullPath));
-          // Skip certain files that shouldn't be uploaded
-          if (shouldSkipFile(relativePath)) {
-            continue;
-          }
-          try {
-            const content = await readFile(fullPath);
-            const fileType = getFileType(relativePath);
-            assets[relativePath] = {
-              content,
-              type: fileType,
-            };
-          } catch (readError) {
-            logFn('warn', `Failed to read file ${fullPath}: ${readError}`);
-          }
-        }
-      }
-    } catch (error) {
-      logFn('warn', `Failed to walk directory ${dirPath}: ${error}`);
-    }
-  }
-  await walkDir(buildDir);
-  return buildAssetsMap(assets, extractBuffer, getAssetType);
-}
-function shouldSkipFile(filePath: string): boolean {
-  // Skip common files that shouldn't be uploaded
-  const skipPatterns = [
-    /\.map$/, // Source maps
-    /node_modules/, // Node modules
-    /\.git/, // Git files
-    /\.DS_Store$/, // macOS files
-    /thumbs\.db$/i, // Windows files
-  ];
-  return skipPatterns.some((pattern) => pattern.test(filePath));
-}
-function getFileType(filePath: string): string {
-  const extension = filePath.split('.').pop()?.toLowerCase() || '';
-  const typeMap: Record<string, string> = {
-    html: 'text/html',
-    css: 'text/css',
-    js: 'application/javascript',
-    mjs: 'application/javascript',
-    json: 'application/json',
-    png: 'image/png',
-    jpg: 'image/jpeg',
-    jpeg: 'image/jpeg',
-    gif: 'image/gif',
-    svg: 'image/svg+xml',
-    ico: 'image/x-icon',
-    woff: 'font/woff',
-    woff2: 'font/woff2',
-    ttf: 'font/ttf',
-    eot: 'application/vnd.ms-fontobject',
-    xml: 'text/xml',
-    txt: 'text/plain',
-  };
-  return typeMap[extension] || 'application/octet-stream';
-}