@emailmaker/emailmaker 1.0.107-dev.3 → 1.0.107-dev.4

package/cli/project-templates/shared/partials/stand-dev-host-vite-subpath.eta

@@ -1,7 +1,6 @@
-import path from 'path';
-import { fileURLToPath } from 'url';
-import { createRequire } from 'module';
-import { createViteStandConfig } from './lib/createViteStandConfig.mjs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createViteStandConfig } from './lib/createViteStandConfig.ts';
 import VitePlugin from '<%~ it.standVitePluginPackage %>/vite';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -15,4 +14,9 @@ export default createViteStandConfig({
   closedLoop: <%= it.standClosedLoop %>,
   plugins: [...VitePlugin({ outputFolder: <%~ JSON.stringify(it.standViteOutputFolder) %> })],
   extraServerMiddlewares: [],
+  build: {
+    rollupOptions: {
+      input: path.resolve(projectRoot, 'advanced', 'subpath', 'index.html'),
+    },
+  },
 });

package/cli/project-templates/shared/partials/stand-dev-host-vite-umd.eta

@@ -1,8 +1,8 @@
-import path from 'path';
-import { fileURLToPath } from 'url';
-import { createRequire } from 'module';
-import { createViteStandConfig } from './lib/createViteStandConfig.mjs';
-import { createUmdServeMiddleware } from './lib/umdServeMiddleware.mjs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createRequire } from 'node:module';
+import { createViteStandConfig } from './lib/createViteStandConfig.ts';
+import { createUmdServeMiddleware } from './lib/umdServeMiddleware.ts';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const projectRoot = path.resolve(__dirname, '..');

package/cli/project-templates/shared/partials/stand-dev-host-vite.eta

@@ -1,6 +1,6 @@
-import path from 'path';
-import { fileURLToPath } from 'url';
-import { createViteStandConfig } from './lib/createViteStandConfig.mjs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createViteStandConfig } from './lib/createViteStandConfig.ts';
 import VitePlugin from '<%~ it.standVitePluginPackage %>/vite';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));

package/cli/project-templates/shared/partials/stand-dev-host-webpack-subpath.eta

@@ -1,12 +1,14 @@
-const path = require('path');
-const { createWebpackStandConfig } = require('./lib/createWebpackStandConfig.cjs');
-const <%= it.standWebpackPluginClassName %> = require('<%~ it.packageName %>/webpack');
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createWebpackStandConfig } from './lib/createWebpackStandConfig.ts';
+import <%= it.standWebpackPluginClassName %> from '<%~ it.packageName %>/webpack';
 
 const umdOpts = null;
 
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const projectRoot = path.resolve(__dirname, '..');
 
-module.exports = createWebpackStandConfig({
+const config = createWebpackStandConfig({
   projectRoot,
   plugins: [new <%= it.standWebpackPluginClassName %>({ publicPath: <%~ JSON.stringify(it.standRoutePath) %> })],
   outputPublicPath: <%~ JSON.stringify(it.standRoutePath) %>,
@@ -25,3 +27,5 @@ module.exports = createWebpackStandConfig({
   ],
   umd: umdOpts,
 });
+
+export default config;

package/cli/project-templates/shared/partials/stand-dev-host-webpack-umd.eta

@@ -1,12 +1,16 @@
-const path = require('path');
-const { createWebpackStandConfig } = require('./lib/createWebpackStandConfig.cjs');
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+import { createWebpackStandConfig } from './lib/createWebpackStandConfig.ts';
 
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const require = createRequire(import.meta.url);
 const umdPackageRoot = path.dirname(require.resolve(<%~ JSON.stringify(it.packageName + '/package.json') %>));
 const umdOpts = { packageRoot: umdPackageRoot, publicPath: <%~ JSON.stringify(it.standUmdPublicPath) %> };
 
 const projectRoot = path.resolve(__dirname, '..');
 
-module.exports = createWebpackStandConfig({
+const config = createWebpackStandConfig({
   projectRoot,
   plugins: [],
   outputPublicPath: <%~ JSON.stringify(it.standRoutePath) %>,
@@ -33,3 +37,5 @@ module.exports = createWebpackStandConfig({
   ],
   umd: umdOpts,
 });
+
+export default config;

package/cli/project-templates/shared/partials/stand-dev-host-webpack.eta

@@ -1,12 +1,14 @@
-const path = require('path');
-const { createWebpackStandConfig } = require('./lib/createWebpackStandConfig.cjs');
-const <%= it.standWebpackPluginClassName %> = require('<%~ it.packageName %>/webpack');
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createWebpackStandConfig } from './lib/createWebpackStandConfig.ts';
+import <%= it.standWebpackPluginClassName %> from '<%~ it.packageName %>/webpack';
 
 const umdOpts = null;
 
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const projectRoot = path.resolve(__dirname, '..');
 
-module.exports = createWebpackStandConfig({
+const config = createWebpackStandConfig({
   projectRoot,
   plugins: [new <%= it.standWebpackPluginClassName %>()],
   outputPublicPath: <%~ JSON.stringify(it.standRoutePath) %>,
@@ -33,3 +35,5 @@ module.exports = createWebpackStandConfig({
   ],
   umd: umdOpts,
 });
+
+export default config;

package/cli/project-templates/shared/partials/stand-dev-storage-middleware.eta

@@ -0,0 +1,370 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import formidable from 'formidable';
+
+interface StorageItem {
+  id: string;
+  name: string;
+  folderId: string;
+  isFolder: boolean;
+  size?: number;
+  date: string;
+  type?: string;
+  url?: string;
+}
+
+interface StorageRequestBody {
+  name?: string;
+  parentId?: string;
+  parentid?: string;
+  folderId?: string;
+  url?: string;
+  path?: string;
+  id?: string;
+}
+
+const STORAGE_DIR = path.resolve(process.cwd(), 'storage');
+const BASE = '/dev-storage';
+
+function ensureDir(dir: string): void {
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+}
+
+function sanitizePath(relativePath: string): string {
+  if (!relativePath || relativePath === '/' || relativePath === '.') {
+    return '';
+  }
+
+  return path.normalize(relativePath).replace(/^(\.\.(\/|\\|$))+/, '').replace(/\\/g, '/').trim();
+}
+
+function resolvePath(relativePath: string): string | null {
+  const safe = sanitizePath(relativePath);
+  const full = path.join(STORAGE_DIR, safe);
+  const resolved = path.resolve(full);
+  if (!resolved.startsWith(path.resolve(STORAGE_DIR))) {
+    return null;
+  }
+
+  return resolved;
+}
+
+function toFileItem(fullPath: string): StorageItem {
+  const stat = fs.statSync(fullPath);
+  const name = path.basename(fullPath);
+  const rel = path.relative(STORAGE_DIR, fullPath).replace(/\\/g, '/');
+  const folderId = path.dirname(rel) === '.' ? '' : path.dirname(rel).replace(/\\/g, '/');
+
+  return {
+    id: rel,
+    name,
+    folderId,
+    isFolder: stat.isDirectory(),
+    size: stat.isFile() ? stat.size : undefined,
+    date: stat.mtime.toISOString(),
+    type: stat.isFile() ? getMimeType(name) : undefined,
+  };
+}
+
+function getMimeType(name: string): string {
+  const ext = path.extname(name).toLowerCase();
+  const types = {
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.png': 'image/png',
+    '.gif': 'image/gif',
+    '.webp': 'image/webp',
+    '.svg': 'image/svg+xml',
+    '.pdf': 'application/pdf',
+    '.zip': 'application/zip',
+  } as const;
+
+  return types[ext as keyof typeof types] || 'application/octet-stream';
+}
+
+function normalizeJsonBody(rawBody: string): StorageRequestBody {
+  if (!rawBody) {
+    return {};
+  }
+
+  const parsed = JSON.parse(rawBody) as Partial<Record<keyof StorageRequestBody, string>>;
+  return {
+    name: typeof parsed.name === 'string' ? parsed.name : undefined,
+    parentId: typeof parsed.parentId === 'string' ? parsed.parentId : undefined,
+    parentid: typeof parsed.parentid === 'string' ? parsed.parentid : undefined,
+    folderId: typeof parsed.folderId === 'string' ? parsed.folderId : undefined,
+    url: typeof parsed.url === 'string' ? parsed.url : undefined,
+    path: typeof parsed.path === 'string' ? parsed.path : undefined,
+    id: typeof parsed.id === 'string' ? parsed.id : undefined,
+  };
+}
+
+function parseJsonBody(req: IncomingMessage): Promise<StorageRequestBody> {
+  return new Promise((resolve) => {
+    let body = '';
+    req.on('data', (chunk: Buffer | string) => {
+      body += typeof chunk === 'string' ? chunk : chunk.toString('utf8');
+    });
+    req.on('end', () => {
+      try {
+        resolve(normalizeJsonBody(body));
+      } catch {
+        resolve({});
+      }
+    });
+  });
+}
+
+function sendJson<T>(res: ServerResponse, data: T, status = 200): void {
+  res.writeHead(status, { 'Content-Type': 'application/json' });
+  res.end(JSON.stringify(data));
+}
+
+function sendItemsResponse(res: ServerResponse, items: StorageItem[]): void {
+  sendJson(res, {
+    items,
+    pagination: { page: 1, limit: 1000, total: items.length, totalPages: 1 },
+  });
+}
+
+async function handleGetItems(_req: IncomingMessage, res: ServerResponse, url: string): Promise<void> {
+  const folderId = (new URL(url, 'http://x').searchParams.get('folderId') || '').trim();
+  const dir = folderId ? resolvePath(folderId) : path.resolve(STORAGE_DIR);
+  if (!dir || !fs.existsSync(dir) || !fs.statSync(dir).isDirectory()) {
+    sendItemsResponse(res, []);
+    return;
+  }
+
+  const items = fs.readdirSync(dir).map((name) => toFileItem(path.join(dir, name)));
+  sendItemsResponse(res, items);
+}
+
+async function handleCreateFolder(req: IncomingMessage, res: ServerResponse): Promise<void> {
+  const body = await parseJsonBody(req);
+  const name = (body.name || '').trim();
+  const parentId = (body.parentId ?? body.parentid ?? '').trim();
+  if (!name || /[\\/:*?"<>|]/.test(name)) {
+    sendJson(res, { error: 'Invalid folder name' }, 400);
+    return;
+  }
+
+  const parentDir = parentId ? resolvePath(parentId) : STORAGE_DIR;
+  if (!parentDir || !fs.existsSync(parentDir)) {
+    sendJson(res, { error: 'Parent folder not found' }, 404);
+    return;
+  }
+
+  const folderPath = path.join(parentDir, name);
+  ensureDir(folderPath);
+  const rel = path.relative(STORAGE_DIR, folderPath).replace(/\\/g, '/');
+  const folderId = path.dirname(rel) === '.' ? '' : path.dirname(rel).replace(/\\/g, '/');
+  sendJson(res, {
+    id: rel,
+    name,
+    folderId,
+    isFolder: true,
+    date: fs.statSync(folderPath).mtime.toISOString(),
+  });
+}
+
+function readFormField(field: string | string[] | undefined): string {
+  if (typeof field === 'string') {
+    return field.trim();
+  }
+
+  if (Array.isArray(field) && typeof field[0] === 'string') {
+    return field[0].trim();
+  }
+
+  return '';
+}
+
+async function handleUpload(req: IncomingMessage, res: ServerResponse): Promise<void> {
+  const form = new formidable.IncomingForm({ multiples: true });
+  const [fields, files] = await new Promise<[formidable.Fields, formidable.Files]>((resolve, reject) => {
+    form.parse(req, (error, parsedFields, parsedFiles) => {
+      if (error) {
+        reject(error);
+        return;
+      }
+
+      resolve([parsedFields, parsedFiles]);
+    });
+  });
+
+  const folderId = readFormField(fields.folderId);
+  const targetDir = folderId ? resolvePath(folderId) : STORAGE_DIR;
+  if (!targetDir || !fs.existsSync(targetDir)) {
+    sendJson(res, { error: 'Folder not found' }, 404);
+    return;
+  }
+
+  const fileEntries = Array.isArray(files.file)
+    ? files.file
+    : files.file
+      ? [files.file]
+      : [];
+  const items: StorageItem[] = [];
+
+  for (const file of fileEntries) {
+    if (!file.filepath || !fs.existsSync(file.filepath)) {
+      continue;
+    }
+
+    const originalName = file.originalFilename || file.newFilename || path.basename(file.filepath);
+    const name = originalName.replace(/[\\/:*?"<>|]/g, '_');
+    const destination = path.join(targetDir, name);
+    fs.copyFileSync(file.filepath, destination);
+
+    const rel = path.relative(STORAGE_DIR, destination).replace(/\\/g, '/');
+    const responseFolderId = path.dirname(rel) === '.' ? '' : path.dirname(rel).replace(/\\/g, '/');
+    items.push({
+      id: rel,
+      name,
+      folderId: responseFolderId,
+      isFolder: false,
+      size: fs.statSync(destination).size,
+      date: fs.statSync(destination).mtime.toISOString(),
+      type: getMimeType(name),
+    });
+  }
+
+  sendJson(res, { items, success: true });
+}
+
+async function handleUploadByUrl(req: IncomingMessage, res: ServerResponse): Promise<void> {
+  const body = await parseJsonBody(req);
+  const url = (body.url || '').trim();
+  const folderId = (body.folderId || '').trim();
+  if (!url) {
+    sendJson(res, { error: 'Missing url' }, 400);
+    return;
+  }
+
+  const targetDir = folderId ? resolvePath(folderId) : STORAGE_DIR;
+  if (!targetDir || !fs.existsSync(targetDir)) {
+    sendJson(res, { error: 'Folder not found' }, 404);
+    return;
+  }
+
+  try {
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error('Fetch failed');
+    }
+
+    const buffer = Buffer.from(await response.arrayBuffer());
+    const name = (url.split('/').pop() || 'file').split('?')[0] || 'file';
+    const destination = path.join(targetDir, name);
+    fs.writeFileSync(destination, buffer);
+
+    const rel = path.relative(STORAGE_DIR, destination).replace(/\\/g, '/');
+    const responseFolderId = path.dirname(rel) === '.' ? '' : path.dirname(rel).replace(/\\/g, '/');
+    sendJson(res, {
+      id: rel,
+      name,
+      folderId: responseFolderId,
+      isFolder: false,
+      size: buffer.length,
+      date: fs.statSync(destination).mtime.toISOString(),
+      type: getMimeType(name),
+      url: `/dev-storage/file/${encodeURIComponent(rel)}`,
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    sendJson(res, { error: message }, 500);
+  }
+}
+
+async function handleDeleteItem(req: IncomingMessage, res: ServerResponse, pathOverride = ''): Promise<void> {
+  let targetPath = pathOverride.trim();
+
+  if (!targetPath) {
+    const pathParam = (new URL(req.url || '/', 'http://x').searchParams.get('path') || '').trim();
+    const body = await parseJsonBody(req);
+    targetPath = pathParam || (body.path || body.id || '').trim();
+  }
+
+  if (!targetPath) {
+    sendJson(res, { error: 'Missing path' }, 400);
+    return;
+  }
+
+  const fullPath = resolvePath(targetPath);
+  if (!fullPath || !fs.existsSync(fullPath)) {
+    sendJson(res, { error: 'Not found' }, 404);
+    return;
+  }
+
+  fs.rmSync(fullPath, { recursive: true });
+  sendJson(res, { success: true });
+}
+
+function handleGetFile(res: ServerResponse, pathPart: string): void {
+  const decoded = decodeURIComponent(pathPart);
+  const fullPath = resolvePath(decoded);
+  if (!fullPath || !fs.existsSync(fullPath) || !fs.statSync(fullPath).isFile()) {
+    res.writeHead(404);
+    res.end();
+    return;
+  }
+
+  const stream = fs.createReadStream(fullPath);
+  const mime = getMimeType(path.basename(fullPath));
+  res.writeHead(200, { 'Content-Type': mime });
+  stream.pipe(res);
+}
+
+export default function devStorageMiddleware() {
+  ensureDir(STORAGE_DIR);
+
+  return (req: IncomingMessage, res: ServerResponse, next: () => void): void => {
+    if (!req.url || !req.url.startsWith(BASE)) {
+      next();
+      return;
+    }
+
+    const pathPart = req.url.slice(BASE.length).replace(/^\//, '');
+    const method = req.method || 'GET';
+
+    if (method === 'GET' && (pathPart === 'items' || pathPart.startsWith('items?'))) {
+      void handleGetItems(req, res, req.url);
+      return;
+    }
+
+    if (method === 'GET' && pathPart.startsWith('file/')) {
+      handleGetFile(res, pathPart.slice(5));
+      return;
+    }
+
+    if (method === 'POST' && pathPart === 'folder') {
+      void handleCreateFolder(req, res);
+      return;
+    }
+
+    if (method === 'POST' && pathPart === 'upload') {
+      void handleUpload(req, res);
+      return;
+    }
+
+    if (method === 'POST' && pathPart === 'upload-by-url') {
+      void handleUploadByUrl(req, res);
+      return;
+    }
+
+    if (method === 'DELETE' && pathPart === 'item') {
+      void handleDeleteItem(req, res);
+      return;
+    }
+
+    if (method === 'DELETE' && pathPart.startsWith('item/')) {
+      void handleDeleteItem(req, res, decodeURIComponent(pathPart.slice(5)));
+      return;
+    }
+
+    next();
+  };
+}

package/cli/project-templates/shared/stand-vite-base/config/lib/createViteStandConfig.ts

@@ -0,0 +1,80 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { PluginOption, UserConfig, UserConfigExport } from 'vite';
+import { defineConfig } from 'vite';
+import devStorageMiddleware from '../../scripts/devStorageMiddleware.ts';
+
+type DevServerMiddleware = (req: IncomingMessage, res: ServerResponse, next: () => void) => void;
+
+interface CreateViteStandConfigOptions {
+  projectRoot: string;
+  open?: string;
+  apiBaseUrl: string;
+  apiOrigin: string;
+  closedLoop?: boolean;
+  plugins?: PluginOption[];
+  extraServerMiddlewares?: DevServerMiddleware[];
+  build?: UserConfig['build'];
+  resolve?: UserConfig['resolve'];
+  serverPort?: number;
+}
+
+export function createViteStandConfig(options: CreateViteStandConfigOptions): UserConfigExport {
+  const {
+    projectRoot,
+    open,
+    apiBaseUrl,
+    apiOrigin,
+    closedLoop,
+    plugins = [],
+    extraServerMiddlewares = [],
+    build,
+    resolve,
+    serverPort = 3000,
+  } = options;
+
+  const proxy: NonNullable<UserConfig['server']>['proxy'] = {
+    '/api': {
+      target: apiBaseUrl,
+      secure: false,
+      changeOrigin: true,
+      configure: (proxyInstance) => {
+        proxyInstance.on('proxyReq', (proxyRequest) => {
+          if (proxyRequest.getHeader('origin')) {
+            proxyRequest.setHeader('origin', apiOrigin);
+          }
+        });
+      },
+    },
+  };
+
+  if (closedLoop) {
+    proxy['/wp-json'] = {
+      target: apiBaseUrl,
+      secure: false,
+      changeOrigin: true,
+    };
+  }
+
+  return defineConfig(() => ({
+    root: projectRoot,
+    plugins: [
+      ...plugins,
+      {
+        name: 'dev-storage',
+        configureServer(server) {
+          server.middlewares.use(devStorageMiddleware());
+          for (const middleware of extraServerMiddlewares) {
+            server.middlewares.use(middleware);
+          }
+        },
+      },
+    ],
+    ...(resolve ? { resolve } : {}),
+    server: {
+      ...(open !== undefined && open !== null ? { open } : {}),
+      port: serverPort,
+      proxy,
+    },
+    ...(build ? { build } : {}),
+  }));
+}

package/cli/project-templates/shared/stand-vite-base/scripts/devStorageMiddleware.ts.eta

@@ -0,0 +1 @@
+<%~ include('stand-dev-storage-middleware', it) %>

package/cli/project-templates/shared/stand-webpack-base/config/lib/{createWebpackStandConfig.cjs → createWebpackStandConfig.ts}

@@ -1,16 +1,33 @@
-const path = require('path');
+import path from 'node:path';
+import type { ClientRequest } from 'node:http';
+import type { Configuration, WebpackPluginInstance } from 'webpack';
+import devStorageMiddleware from '../../scripts/devStorageMiddleware.ts';
+import { createUmdServeMiddleware } from './umdServeMiddleware.ts';
 
-/**
- * @param {object} options
- * @param {string} options.projectRoot
- * @param {any[]} options.plugins
- * @param {string} options.outputPublicPath
- * @param {string} options.staticDirectory — абсолютный путь к static directory
- * @param {string} options.open
- * @param {object[]} options.proxy
- * @param {{ packageRoot: string; publicPath: string } | null} [options.umd]
- */
-function createWebpackStandConfig(options) {
+interface UmdServeOptions {
+  packageRoot: string;
+  publicPath: string;
+}
+
+interface ProxyRule {
+  context: string[];
+  target: string;
+  secure: boolean;
+  changeOrigin: boolean;
+  onProxyReq?: (proxyRequest: ClientRequest) => void;
+}
+
+interface CreateWebpackStandConfigOptions {
+  projectRoot: string;
+  plugins: WebpackPluginInstance[];
+  outputPublicPath: string;
+  staticDirectory: string;
+  open: string;
+  proxy: ProxyRule[];
+  umd?: UmdServeOptions | null;
+}
+
+export function createWebpackStandConfig(options: CreateWebpackStandConfigOptions): Configuration {
   const {
     projectRoot,
     plugins,
@@ -21,9 +38,6 @@ function createWebpackStandConfig(options) {
     umd,
   } = options;
 
-  const devStorage = require(path.resolve(projectRoot, 'scripts/devStorageMiddleware.cjs'));
-  const { createUmdServeMiddleware } = require(path.join(__dirname, 'umdServeMiddleware.cjs'));
-
   const umdMiddleware = umd ? createUmdServeMiddleware(umd) : null;
 
   return {
@@ -65,9 +79,9 @@ function createWebpackStandConfig(options) {
       liveReload: true,
       allowedHosts: 'all',
       setupMiddlewares: (middlewares, devServer) => {
-        devServer.app.use(devStorage());
+        devServer.app?.use(devStorageMiddleware());
         if (umdMiddleware) {
-          devServer.app.use(umdMiddleware);
+          devServer.app?.use(umdMiddleware);
         }
         return middlewares;
       },
@@ -75,5 +89,3 @@ function createWebpackStandConfig(options) {
     },
   };
 }
-
-module.exports = { createWebpackStandConfig };