@emailmaker/emailmaker 1.0.1

package/ts.worker.js.LICENSE.txt

@@ -0,0 +1,21 @@
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation. All rights reserved.
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this file except in compliance with the License. You may obtain a copy of the
+License at http://www.apache.org/licenses/LICENSE-2.0
+
+THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+MERCHANTABLITY OR NON-INFRINGEMENT.
+
+See the Apache Version 2.0 License for specific language governing permissions
+and limitations under the License.
+***************************************************************************** */
+
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.34.0(dee69564fa27426c7ebb706c3d2ed3d1acccedfe)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/

package/vite/index.d.ts

@@ -0,0 +1,11 @@
+type PluginOptions = {
+  publicPath?: string;
+  outputFolder?: string;
+  modulesPath?: string;
+};
+
+
+export default function VitePlugin(options?: PluginOptions): {
+  name: string;
+  apply: "serve" | "build";
+}[];

package/vite/index.js

@@ -0,0 +1,136 @@
+const path = require("path");
+const fs = require("fs");
+const MIME_TYPES = require("./mime-types");
+const { toPascalCase, cleanUrl, normalizePath, copyFolder } = require("./utils");
+
+const PACKAGE_PATH = require("./../package.json").name;
+const APP_NAME = PACKAGE_PATH.split("/").pop().replace("-dev", "");
+const ENVIRONMENT_VARIABLE = `${toPascalCase(APP_NAME)}Environment`;
+const PLUGIN_NAME = `${APP_NAME}-vite-plugin`;
+const PACKAGE_ENTRY_NAME = `${APP_NAME}.js`;
+const ESM_PACKAGE_ENTRY_NAME = `${APP_NAME}-esm.js`;
+const DEFAULT_OUTPUT_FOLDER = `/${APP_NAME}`;
+const DEFAULT_MODULES_PATH = "node_modules";
+console.log(PACKAGE_PATH);
+
+const IGNORED_PATTERNS = [
+  /.*\.npmignore/,
+  /.*\.gitignore/,
+  /.*\.md$/,
+  /.*\.ts$/,
+  /.*\.d\.ts$/,
+  /.*\.json$/,
+  /.*\.ico$/,
+  /.*\.pot$/,
+  /^.*(?<!iframe\..{1,})\.html$/,
+  /vite\\?.*$/,
+  /webpack\\?.*$/,
+  /react\\?.*$/,
+  /robots.txt$/,
+  /main\..*\.js$/,
+  /.*\\sandbox-eblock.*$/
+];
+
+const ViteServePlugin = (options) => {
+  const rootPath = process.cwd();
+  const destPath = path.posix.join(rootPath, options.outputFolder || DEFAULT_OUTPUT_FOLDER);
+  return {
+    name: PLUGIN_NAME,
+    apply: 'serve',
+
+    transform: (code, id) => {
+      id = cleanUrl(id);
+      const packageName = `${PACKAGE_PATH.replaceAll("/", "_")}.js`
+      return (id.endsWith(packageName) || id.endsWith(ESM_PACKAGE_ENTRY_NAME)) ? `var ${ENVIRONMENT_VARIABLE}= { publicPath: "${options.outputFolder || DEFAULT_OUTPUT_FOLDER}/"}; ${code}` : code;
+    },
+
+    configureServer: (server) => {
+      server.middlewares.use('/', async (req, res, next) => {
+        if (!req.url) {
+          next();
+          return;
+        }
+        const absReqPath = path.posix.join(rootPath, cleanUrl(req.url));
+        if (absReqPath.startsWith(destPath)) {
+          const sourcePath = path.posix.join(options.modulesPath || DEFAULT_MODULES_PATH, PACKAGE_PATH, absReqPath.replace(destPath, ""));
+          if (!IGNORED_PATTERNS.some((pattern) => pattern.test(sourcePath)) && fs.existsSync(sourcePath)) {
+            await sendContentByFilePath(sourcePath);
+            return;
+          }
+        }
+        next()
+
+        async function sendContentByFilePath(filePath) {
+          const handledPath = normalizePath(filePath);
+          if (!fs.existsSync(handledPath)) {
+            next();
+            return;
+          }
+          if (!fs.statSync(handledPath).isFile()) {
+            next();
+            return;
+          }
+          const content = await fs.promises.readFile(handledPath);
+          const filePathParts = filePath.split(".");
+          const ext = filePathParts.length > 1 ? filePathParts[filePathParts.length - 1] : "";
+          res.writeHead(200, {
+            'Content-Type': ext && MIME_TYPES[ext] || 'text/plain'
+          });
+          res.end(content)
+        }
+      })
+
+    }
+  }
+};
+
+const ViteBuildPlugin = (options) => {
+  const publicPath = options.publicPath || "";
+  const sourcePath = path.posix.join(options.modulesPath || DEFAULT_MODULES_PATH, PACKAGE_PATH);
+  let resolvedConfig = undefined;
+  return {
+    name: PLUGIN_NAME,
+    apply: 'build',
+    transform: (code, id) => {
+      id = cleanUrl(id);
+      if (id.endsWith(PACKAGE_ENTRY_NAME) || id.endsWith(ESM_PACKAGE_ENTRY_NAME)) {
+        const dir = path.posix.join(publicPath, options.outputFolder || DEFAULT_OUTPUT_FOLDER);
+        return `let ${ENVIRONMENT_VARIABLE}= { publicPath: "${dir}/"}; ${code}`;
+      } else {
+        return code;
+      }
+    },
+    configResolved(config) {
+      resolvedConfig = config
+    },
+    async closeBundle() {
+      const outDir = path.posix.join(
+        resolvedConfig.root,
+        resolvedConfig.build.outDir
+      )
+      const destPath = path.posix.join(outDir, options.outputFolder || DEFAULT_OUTPUT_FOLDER);
+
+      if (!fs.existsSync(sourcePath)) {
+        return
+      }
+
+
+      const stat = await fs.promises.stat(sourcePath)
+
+      if (stat.isDirectory()) {
+        await copyFolder(sourcePath, destPath, (sourcePath) => {
+          console.log(`${sourcePath} ${!IGNORED_PATTERNS.some((pattern) => pattern.test(sourcePath))}`);
+          return !IGNORED_PATTERNS.some((pattern) => pattern.test(sourcePath));
+        }
+        )
+      }
+
+    }
+  }
+}
+
+const VitePlugin = (options = {}) => {
+  return [ViteServePlugin(options), ViteBuildPlugin(options)]
+}
+
+module.exports = VitePlugin;

package/vite/mime-types.js

@@ -0,0 +1,179 @@
+module.exports = {
+  //   File Extension   MIME Type
+  'abs': 'audio/x-mpeg',
+  'ai': 'application/postscript',
+  'aif': 'audio/x-aiff',
+  'aifc': 'audio/x-aiff',
+  'aiff': 'audio/x-aiff',
+  'aim': 'application/x-aim',
+  'art': 'image/x-jg',
+  'asf': 'video/x-ms-asf',
+  'asx': 'video/x-ms-asf',
+  'au': 'audio/basic',
+  'avi': 'video/x-msvideo',
+  'avx': 'video/x-rad-screenplay',
+  'bcpio': 'application/x-bcpio',
+  'bin': 'application/octet-stream',
+  'bmp': 'image/bmp',
+  'body': 'text/html',
+  'cdf': 'application/x-cdf',
+  'cer': 'application/pkix-cert',
+  'class': 'application/java',
+  'cpio': 'application/x-cpio',
+  'csh': 'application/x-csh',
+  'css': 'text/css',
+  'dib': 'image/bmp',
+  'doc': 'application/msword',
+  'dtd': 'application/xml-dtd',
+  'dv': 'video/x-dv',
+  'dvi': 'application/x-dvi',
+  'eot': 'application/vnd.ms-fontobject',
+  'eps': 'application/postscript',
+  'etx': 'text/x-setext',
+  'exe': 'application/octet-stream',
+  'gif': 'image/gif',
+  'gtar': 'application/x-gtar',
+  'gz': 'application/x-gzip',
+  'hdf': 'application/x-hdf',
+  'hqx': 'application/mac-binhex40',
+  'htc': 'text/x-component',
+  'htm': 'text/html',
+  'html': 'text/html',
+  'ief': 'image/ief',
+  'jad': 'text/vnd.sun.j2me.app-descriptor',
+  'jar': 'application/java-archive',
+  'java': 'text/x-java-source',
+  'jnlp': 'application/x-java-jnlp-file',
+  'jpe': 'image/jpeg',
+  'jpeg': 'image/jpeg',
+  'jpg': 'image/jpeg',
+  'js': 'application/javascript',
+  'jsf': 'text/plain',
+  'json': 'application/json',
+  'jspf': 'text/plain',
+  'kar': 'audio/midi',
+  'latex': 'application/x-latex',
+  'm3u': 'audio/x-mpegurl',
+  'mac': 'image/x-macpaint',
+  'man': 'text/troff',
+  'mathml': 'application/mathml+xml',
+  'me': 'text/troff',
+  'mid': 'audio/midi',
+  'midi': 'audio/midi',
+  'mif': 'application/x-mif',
+  'mov': 'video/quicktime',
+  'movie': 'video/x-sgi-movie',
+  'mp1': 'audio/mpeg',
+  'mp2': 'audio/mpeg',
+  'mp3': 'audio/mpeg',
+  'mp4': 'video/mp4',
+  'mpa': 'audio/mpeg',
+  'mpe': 'video/mpeg',
+  'mpeg': 'video/mpeg',
+  'mpega': 'audio/x-mpeg',
+  'mpg': 'video/mpeg',
+  'mpv2': 'video/mpeg2',
+  'ms': 'application/x-wais-source',
+  'nc': 'application/x-netcdf',
+  'oda': 'application/oda',
+  'odb': 'application/vnd.oasis.opendocument.database',
+  'odc': 'application/vnd.oasis.opendocument.chart',
+  'odf': 'application/vnd.oasis.opendocument.formula',
+  'odg': 'application/vnd.oasis.opendocument.graphics',
+  'odi': 'application/vnd.oasis.opendocument.image',
+  'odm': 'application/vnd.oasis.opendocument.text-master',
+  'odp': 'application/vnd.oasis.opendocument.presentation',
+  'ods': 'application/vnd.oasis.opendocument.spreadsheet',
+  'odt': 'application/vnd.oasis.opendocument.text',
+  'otg': 'application/vnd.oasis.opendocument.graphics-template',
+  'oth': 'application/vnd.oasis.opendocument.text-web',
+  'otp': 'application/vnd.oasis.opendocument.presentation-template',
+  'ots': 'application/vnd.oasis.opendocument.spreadsheet-template',
+  'ott': 'application/vnd.oasis.opendocument.text-template',
+  'ogx': 'application/ogg',
+  'ogv': 'video/ogg',
+  'oga': 'audio/ogg',
+  'ogg': 'audio/ogg',
+  'otf': 'application/x-font-opentype',
+  'spx': 'audio/ogg',
+  'flac': 'audio/flac',
+  'anx': 'application/annodex',
+  'axa': 'audio/annodex',
+  'axv': 'video/annodex',
+  'xspf': 'application/xspf+xml',
+  'pbm': 'image/x-portable-bitmap',
+  'pct': 'image/pict',
+  'pdf': 'application/pdf',
+  'pgm': 'image/x-portable-graymap',
+  'pic': 'image/pict',
+  'pict': 'image/pict',
+  'pls': 'audio/x-scpls',
+  'png': 'image/png',
+  'pnm': 'image/x-portable-anymap',
+  'pnt': 'image/x-macpaint',
+  'ppm': 'image/x-portable-pixmap',
+  'ppt': 'application/vnd.ms-powerpoint',
+  'pps': 'application/vnd.ms-powerpoint',
+  'ps': 'application/postscript',
+  'psd': 'image/vnd.adobe.photoshop',
+  'qt': 'video/quicktime',
+  'qti': 'image/x-quicktime',
+  'qtif': 'image/x-quicktime',
+  'ras': 'image/x-cmu-raster',
+  'rdf': 'application/rdf+xml',
+  'rgb': 'image/x-rgb',
+  'rm': 'application/vnd.rn-realmedia',
+  'roff': 'text/troff',
+  'rtf': 'application/rtf',
+  'rtx': 'text/richtext',
+  'sfnt': 'application/font-sfnt',
+  'sh': 'application/x-sh',
+  'shar': 'application/x-shar',
+  'sit': 'application/x-stuffit',
+  'snd': 'audio/basic',
+  'src': 'application/x-wais-source',
+  'sv4cpio': 'application/x-sv4cpio',
+  'sv4crc': 'application/x-sv4crc',
+  'svg': 'image/svg+xml',
+  'svgz': 'image/svg+xml',
+  'swf': 'application/x-shockwave-flash',
+  't': 'text/troff',
+  'tar': 'application/x-tar',
+  'tcl': 'application/x-tcl',
+  'tex': 'application/x-tex',
+  'texi': 'application/x-texinfo',
+  'texinfo': 'application/x-texinfo',
+  'tif': 'image/tiff',
+  'tiff': 'image/tiff',
+  'tr': 'text/troff',
+  'tsv': 'text/tab-separated-values',
+  'ttf': 'application/x-font-ttf',
+  'txt': 'text/plain',
+  'ulw': 'audio/basic',
+  'ustar': 'application/x-ustar',
+  'vxml': 'application/voicexml+xml',
+  'xbm': 'image/x-xbitmap',
+  'xht': 'application/xhtml+xml',
+  'xhtml': 'application/xhtml+xml',
+  'xls': 'application/vnd.ms-excel',
+  'xml': 'application/xml',
+  'xpm': 'image/x-xpixmap',
+  'xsl': 'application/xml',
+  'xslt': 'application/xslt+xml',
+  'xul': 'application/vnd.mozilla.xul+xml',
+  'xwd': 'image/x-xwindowdump',
+  'vsd': 'application/vnd.visio',
+  'wav': 'audio/x-wav',
+  'wbmp': 'image/vnd.wap.wbmp',
+  'wml': 'text/vnd.wap.wml',
+  'wmlc': 'application/vnd.wap.wmlc',
+  'wmls': 'text/vnd.wap.wmlsc',
+  'wmlscriptc': 'application/vnd.wap.wmlscriptc',
+  'wmv': 'video/x-ms-wmv',
+  'woff': 'application/font-woff',
+  'woff2': 'application/font-woff2',
+  'wrl': 'model/vrml',
+  'wspolicy': 'application/wspolicy+xml',
+  'z': 'application/x-compress',
+  'zip': 'application/zip'
+};

package/vite/utils.js

@@ -0,0 +1,58 @@
+const path = require("path");
+const os = require("os");
+
+const {
+  mkdir,
+  readdir,
+  copyFile,
+  stat
+} = require("fs").promises;
+
+function toPascalCase(string) {
+  return `${string}`
+    .toLowerCase()
+    .replace(new RegExp(/[-_]+/, 'g'), ' ')
+    .replace(new RegExp(/[^\w\s]/, 'g'), '')
+    .replace(
+      new RegExp(/\s+(.)(\w*)/, 'g'),
+      ($1, $2, $3) => `${$2.toUpperCase() + $3}`
+    )
+    .replace(new RegExp(/\w/), s => s.toUpperCase());
+}
+
+function slash(p) {
+  return p.replace(/\\/g, '/')
+}
+
+const cleanUrl = (url) => {
+  const QUERY_RE = /\?.*$/s
+  const HASH_RE = /#.*$/s
+  return url.replace(HASH_RE, '').replace(QUERY_RE, '')
+}
+
+function normalizePath(id) {
+  const isWindows = os.platform() === 'win32'
+  return path.posix.normalize(isWindows ? slash(id) : id)
+}
+
+const fileExists = async path => !!(await stat(path).catch(e => false));
+
+async function copyFolder(src, dest, filter) {
+  if (!await fileExists(dest)) {
+    await mkdir(dest);
+  }
+  const entries = await readdir(src);
+  return Promise.all(entries.map(async entry => {
+    const srcPath = path.join(src, entry);
+    if (filter(srcPath)) {
+      const destPath = path.join(dest, entry);
+      const _stat = await stat(srcPath);
+      if (_stat.isFile()) {
+        copyFile(srcPath, destPath);
+      } else if (_stat.isDirectory()) {
+        copyFolder(srcPath, destPath, filter);
+      }
+    }
+  }));
+}
+module.exports = { toPascalCase, cleanUrl, normalizePath, copyFolder };

package/webpack/index.d.ts

@@ -0,0 +1,12 @@
+import { Compiler, WebpackPluginInstance } from "webpack";
+
+export type WebpackPluginOptions = {
+  outputFolder?: string;
+  modulesPath?: string;
+  publicPath?: string;
+}
+
+export default class WebpackPlugin implements WebpackPluginInstance {
+  constructor(options: WebpackPluginOptions);
+  apply: (compiler: Compiler) => void;
+}

package/webpack/index.js

@@ -0,0 +1,109 @@
+const path = require('path');
+const fs = require('fs');
+const { javascript } = require("webpack");
+const { ConcatSource, RawSource } = require("webpack-sources");
+
+function toPascalCase(string) {
+  return `${string}`
+    .toLowerCase()
+    .replace(new RegExp(/[-_]+/, 'g'), ' ')
+    .replace(new RegExp(/[^\w\s]/, 'g'), '')
+    .replace(
+      new RegExp(/\s+(.)(\w*)/, 'g'),
+      ($1, $2, $3) => `${$2.toUpperCase() + $3}`
+    )
+    .replace(new RegExp(/\w/), s => s.toUpperCase());
+}
+
+
+const PACKAGE_PATH = require("./../package.json").name;
+const APP_NAME = PACKAGE_PATH.split("/").pop().replace("-dev", "");
+const PLUGIN_NAME = `${toPascalCase(APP_NAME)}WebpackPlugin`;
+const PACKAGE_ENTRY_NAME = `${APP_NAME}.js`;
+const DEFAULT_OUTPUT_FOLDER = APP_NAME;
+const DEFAULT_MODULES_PATH = `node_modules`;
+const ESM_PACKAGE_ENTRY_NAME = `${APP_NAME}-esm.js`;
+const ENVIRONMENT_VARIABLE = `${toPascalCase(APP_NAME)}Environment`;
+
+const IGNORED_PATTERNS = [
+  /.*\.npmignore/,
+  /.*\.gitignore/,
+  /.*\.md$/,
+  /.*\.ts$/,
+  /.*\.d\.ts$/,
+  /.*\.json$/,
+  /.*\.ico$/,
+  /.*\.pot$/,
+  /^.*(?<!iframe\..{1,})\.html$/,
+  /vite\\?.*$/,
+  /webpack\\?.*$/,
+  /react\\?.*$/,
+  /robots.txt$/,
+  /main\..*\.js$/,
+  /.*\\sandbox-eblock.*$/
+];
+
+class WebpackPlugin {
+  _outputFolder = DEFAULT_OUTPUT_FOLDER;
+  _modulesPath = DEFAULT_MODULES_PATH;
+  _publicPath = undefined;
+  constructor(options = {}) {
+    if (options.outputFolder !== undefined) { this._outputFolder = options.outputFolder; };
+    if (options.modulesPath !== undefined) { this._modulesPath = options.modulesPath };
+    if (options.publicPath !== undefined) { this._publicPath = options.publicPath };
+  }
+
+
+  addAsset = async (compilation, sourcePath, destPath) => {
+    const filePath = path.resolve(compilation.compiler.context, sourcePath);
+    if (IGNORED_PATTERNS.some((pattern) => pattern.test(filePath))) {
+      return;
+    }
+    if (!compilation.getAsset(destPath)) {
+      const [stat, data] = await Promise.all([fs.promises.stat(filePath), fs.promises.readFile(filePath)]);
+      const { size } = stat;
+      const source = new RawSource(data, true);
+      compilation.fileDependencies.add(filePath);
+      compilation.emitAsset(destPath, source, { size });
+    }
+  };
+
+  copyFiles = async (compilation, source, destination) => {
+    const directoryEntries = await fs.promises.readdir(source, { withFileTypes: true });
+    // console.log(destination);
+    // await fs.promises.mkdir(destination, { recursive: true });
+    return Promise.all(
+      directoryEntries.map(async (entry) => {
+        const sourcePath = path.join(source, entry.name);
+        const destinationPath = path.join(destination, entry.name);
+        return entry.isDirectory() ?
+          this.copyFiles(compilation, sourcePath, destinationPath) :
+          this.addAsset(compilation, sourcePath, destinationPath);
+      })
+    );
+
+  };
+
+  apply(compiler) {
+    const optionsPublicPath = compiler.options.output.publicPath || "";
+    const publicPath = this._publicPath === undefined ? optionsPublicPath : this._publicPath;
+    const initFragment = `var ${ENVIRONMENT_VARIABLE} = { publicPath: "${publicPath + (publicPath.endsWith("/") ? "" : "/")}${this._outputFolder}/"};`;
+    compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => {
+      compilation.hooks.processAssets.tapAsync({
+        name: PLUGIN_NAME,
+        stage: compiler.webpack.Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL,
+      },
+        (_unusedAssets, cb) => this.copyFiles(compilation, path.join(this._modulesPath, PACKAGE_PATH), this._outputFolder).then(() => cb(null), e => cb(e)));
+      const hooks = javascript.JavascriptModulesPlugin.getCompilationHooks(compilation);
+      hooks.renderModuleContent.tap(PLUGIN_NAME, (source, module) => {
+        const name = module && module.nameForCondition();
+        if (typeof name === "string" && (name.indexOf(PACKAGE_ENTRY_NAME) >= 0 || name.indexOf(ESM_PACKAGE_ENTRY_NAME) >= 0)) {
+          return new ConcatSource(initFragment, source);
+        }
+        return source;
+      });
+    });
+  }
+}
+
+module.exports = WebpackPlugin;