@meethive/vite 0.0.1

package/src/monaco-editor/workerMiddleware.ts

@@ -0,0 +1,78 @@
+import { Connect, ResolvedConfig } from 'vite';
+import { getWorks, IMonacoEditorOpts, isCDN, resolveMonacoPath } from './index';
+import { IWorkerDefinition } from './languageWork';
+import { buildSync } from 'esbuild'
+import { type RmDirOptions, existsSync, readFileSync, rmSync } from 'fs';
+import {  basename } from 'path';
+
+export function getFilenameByEntry(entry: string) {
+  entry = basename(entry, 'js');
+  return entry + '.bundle.js';
+}
+
+export const cacheDir = 'node_modules/.monaco/';
+
+export function getWorkPath(
+  works: IWorkerDefinition[],
+  options: IMonacoEditorOpts,
+  config: ResolvedConfig
+) {
+  const workerPaths = {};
+
+  for (const work of works) {
+    if (isCDN(options.publicPath)) {
+      workerPaths[work.label] = options.publicPath + '/' + getFilenameByEntry(work.entry);
+    } else {
+      workerPaths[work.label] =
+        config.base + options.publicPath + '/' + getFilenameByEntry(work.entry);
+    }
+  }
+
+  if (workerPaths['typescript']) {
+    // javascript shares the same worker
+    workerPaths['javascript'] = workerPaths['typescript'];
+  }
+  if (workerPaths['css']) {
+    // scss and less share the same worker
+    workerPaths['less'] = workerPaths['css'];
+    workerPaths['scss'] = workerPaths['css'];
+  }
+  if (workerPaths['html']) {
+    // handlebars, razor and html share the same worker
+    workerPaths['handlebars'] = workerPaths['html'];
+    workerPaths['razor'] = workerPaths['html'];
+  }
+
+  return workerPaths;
+}
+
+export function workerMiddleware(
+  middlewares: Connect.Server,
+  config: ResolvedConfig,
+  options: IMonacoEditorOpts
+): void {
+  const works = getWorks(options);
+  // clear cacheDir
+
+  if (existsSync(cacheDir)) {
+    rmSync(cacheDir, { recursive: true, force: true } as RmDirOptions);
+  }
+
+  for (const work of works) {
+    middlewares.use(
+      config.base + options.publicPath + '/' + getFilenameByEntry(work.entry),
+      function (req, res, next) {
+        if (!existsSync(cacheDir + getFilenameByEntry(work.entry))) {
+          buildSync({
+            entryPoints: [resolveMonacoPath(work.entry)],
+            bundle: true,
+            outfile: cacheDir + getFilenameByEntry(work.entry),
+          });
+        }
+        const contentBuffer = readFileSync(cacheDir + getFilenameByEntry(work.entry));
+        res.setHeader('Content-Type', 'text/javascript');
+        res.end(contentBuffer);
+      }
+    );
+  }
+}

package/src/sharp/index.ts

@@ -0,0 +1,93 @@
+import type { Plugin } from 'vite'
+import path from 'node:path'
+
+// A simple Vite plugin that optimizes emitted image assets with sharp during build
+// It runs in generateBundle to ensure we only process final assets.
+
+export type SharpOptimizeOptions = {
+  include?: (string | RegExp)[]
+  exclude?: (string | RegExp)[]
+  jpegQuality?: number
+  pngQuality?: number // 0-100
+  webpQuality?: number
+  avifQuality?: number
+}
+
+function matches(filename: string, patterns?: (string | RegExp)[]): boolean {
+  if (!patterns || patterns.length === 0) return true
+  return patterns.some((p) =>
+    typeof p === 'string' ? filename.includes(p) : (p as RegExp).test(filename)
+  )
+}
+
+export default function sharpOptimize(options: SharpOptimizeOptions = {}): Plugin {
+  const {
+    include,
+    exclude,
+    jpegQuality = 75,
+    pngQuality = 75,
+    webpQuality = 75,
+    avifQuality = 50,
+  } = options
+
+  // lazy require to avoid loading sharp in non-build contexts and allow it to be externalized
+  let _sharp: typeof import('sharp') | null = null
+  const getSharp = async () => {
+    if (!_sharp) {
+      // eslint-disable-next-line @typescript-eslint/no-var-requires
+      const sharpModule = await import('sharp')
+      _sharp = (sharpModule.default ?? sharpModule) as typeof import('sharp')
+    }
+    return _sharp!
+  }
+
+  const imageExts = new Set(['.png', '.jpg', '.jpeg', '.webp', '.avif'])
+
+  return {
+    name: 'jetlinks-sharp-optimize',
+    apply: 'build',
+    enforce: 'post',
+    async generateBundle(_opts, bundle) {
+      for (const [fileName, asset] of Object.entries(bundle)) {
+        if (asset.type !== 'asset') continue
+        const ext = path.extname(fileName).toLowerCase()
+        if (!imageExts.has(ext)) continue
+        if (exclude && matches(fileName, exclude)) continue
+        if (include && !matches(fileName, include)) continue
+
+        try {
+          const sourceBuffer = Buffer.isBuffer(asset.source)
+            ? (asset.source as Buffer)
+            : Buffer.from(String(asset.source))
+
+          const sharp = await getSharp()
+          let instance = sharp(sourceBuffer)
+
+          switch (ext) {
+            case '.jpg':
+            case '.jpeg':
+              instance = instance.jpeg({ quality: jpegQuality, mozjpeg: true })
+              break
+            case '.png':
+              // sharp png quality maps to zlib level & palette; 0-100
+              instance = instance.png({ quality: pngQuality, compressionLevel: 9 })
+              break
+            case '.webp':
+              instance = instance.webp({ quality: webpQuality })
+              break
+            case '.avif':
+              instance = instance.avif({ quality: avifQuality })
+              break
+            default:
+              break
+          }
+
+          const optimized = await instance.toBuffer()
+          asset.source = optimized
+        } catch (err) {
+          this.warn(`sharp optimize failed for ${fileName}: ${String(err)}`)
+        }
+      }
+    },
+  }
+}