create-jen-app 1.2.2 → 1.2.3

package/templates/static/lib/compilers/esbuild-plugins.js

@@ -21,110 +21,108 @@ import { createSvelteCompiler } from "./svelte.js";
 const vueCache = new Map();
 const svelteCache = new Map();
 export function vueEsbuildPlugin() {
-    const compiler = createVueCompiler();
-    return {
-        name: "vue",
-        setup(build) {
-            build.onLoad({ filter: /\.vue$/ }, async (args) => {
-                try {
-                    // Check cache
-                    if (vueCache.has(args.path)) {
-                        return {
-                            contents: vueCache.get(args.path),
-                            loader: "js",
-                        };
-                    }
-                    const source = readFileSync(args.path, "utf-8");
-                    const result = compiler.compile(source, {
-                        filename: args.path,
-                        id: args.path.replace(/[^a-z0-9]/gi, "_"),
-                    });
-                    if (result.error) {
-                        return {
-                            errors: [
-                                {
-                                    text: `Vue compilation failed: ${result.error}`,
-                                    location: { file: args.path, line: 1, column: 0 },
-                                },
-                            ],
-                        };
-                    }
-                    vueCache.set(args.path, result.code);
-                    return {
-                        contents: result.code,
-                        loader: "js",
-                    };
-                }
-                catch (err) {
-                    return {
-                        errors: [
-                            {
-                                text: `Vue plugin error: ${String(err)}`,
-                                location: { file: args.path, line: 1, column: 0 },
-                            },
-                        ],
-                    };
-                }
-            });
-        },
-    };
+  const compiler = createVueCompiler();
+  return {
+    name: "vue",
+    setup(build) {
+      build.onLoad({ filter: /\.vue$/ }, async (args) => {
+        try {
+          // Check cache
+          if (vueCache.has(args.path)) {
+            return {
+              contents: vueCache.get(args.path),
+              loader: "js",
+            };
+          }
+          const source = readFileSync(args.path, "utf-8");
+          const result = compiler.compile(source, {
+            filename: args.path,
+            id: args.path.replace(/[^a-z0-9]/gi, "_"),
+          });
+          if (result.error) {
+            return {
+              errors: [
+                {
+                  text: `Vue compilation failed: ${result.error}`,
+                  location: { file: args.path, line: 1, column: 0 },
+                },
+              ],
+            };
+          }
+          vueCache.set(args.path, result.code);
+          return {
+            contents: result.code,
+            loader: "js",
+          };
+        } catch (err) {
+          return {
+            errors: [
+              {
+                text: `Vue plugin error: ${String(err)}`,
+                location: { file: args.path, line: 1, column: 0 },
+              },
+            ],
+          };
+        }
+      });
+    },
+  };
 }
 export function svelteEsbuildPlugin() {
-    const compiler = createSvelteCompiler();
-    return {
-        name: "svelte",
-        setup(build) {
-            build.onLoad({ filter: /\.svelte$/ }, async (args) => {
-                try {
-                    // Check cache
-                    if (svelteCache.has(args.path)) {
-                        return {
-                            contents: svelteCache.get(args.path),
-                            loader: "js",
-                        };
-                    }
-                    const source = readFileSync(args.path, "utf-8");
-                    const result = compiler.compile(source, {
-                        filename: args.path,
-                        dev: process.env.NODE_ENV !== "production",
-                    });
-                    if (result.error) {
-                        return {
-                            errors: [
-                                {
-                                    text: `Svelte compilation failed: ${result.error}`,
-                                    location: { file: args.path, line: 1, column: 0 },
-                                },
-                            ],
-                        };
-                    }
-                    svelteCache.set(args.path, result.code);
-                    return {
-                        contents: result.code,
-                        loader: "js",
-                    };
-                }
-                catch (err) {
-                    return {
-                        errors: [
-                            {
-                                text: `Svelte plugin error: ${String(err)}`,
-                                location: { file: args.path, line: 1, column: 0 },
-                            },
-                        ],
-                    };
-                }
-            });
-        },
-    };
+  const compiler = createSvelteCompiler();
+  return {
+    name: "svelte",
+    setup(build) {
+      build.onLoad({ filter: /\.svelte$/ }, async (args) => {
+        try {
+          // Check cache
+          if (svelteCache.has(args.path)) {
+            return {
+              contents: svelteCache.get(args.path),
+              loader: "js",
+            };
+          }
+          const source = readFileSync(args.path, "utf-8");
+          const result = compiler.compile(source, {
+            filename: args.path,
+            dev: process.env.NODE_ENV !== "production",
+          });
+          if (result.error) {
+            return {
+              errors: [
+                {
+                  text: `Svelte compilation failed: ${result.error}`,
+                  location: { file: args.path, line: 1, column: 0 },
+                },
+              ],
+            };
+          }
+          svelteCache.set(args.path, result.code);
+          return {
+            contents: result.code,
+            loader: "js",
+          };
+        } catch (err) {
+          return {
+            errors: [
+              {
+                text: `Svelte plugin error: ${String(err)}`,
+                location: { file: args.path, line: 1, column: 0 },
+              },
+            ],
+          };
+        }
+      });
+    },
+  };
 }
 export function invalidateVueCache(filePath) {
-    vueCache.delete(filePath);
+  vueCache.delete(filePath);
 }
 export function invalidateSvelteCache(filePath) {
-    svelteCache.delete(filePath);
+  svelteCache.delete(filePath);
 }
 export function clearAllCompilerCaches() {
-    vueCache.clear();
-    svelteCache.clear();
+  vueCache.clear();
+  svelteCache.clear();
 }

package/templates/static/lib/compilers/svelte.d.ts

@@ -1,18 +1,18 @@
 export interface SvelteCompileOptions {
-    filename?: string;
-    dev?: boolean;
-    minified?: boolean;
-    hydratable?: boolean;
+  filename?: string;
+  dev?: boolean;
+  minified?: boolean;
+  hydratable?: boolean;
 }
 export interface SvelteCompileResult {
+  code: string;
+  css?: {
     code: string;
-    css?: {
-        code: string;
-        map?: any;
-    };
-    error?: string;
+    map?: any;
+  };
+  error?: string;
 }
 export declare class SvelteCompiler {
-    compile(source: string, options: SvelteCompileOptions): SvelteCompileResult;
+  compile(source: string, options: SvelteCompileOptions): SvelteCompileResult;
 }
 export declare function createSvelteCompiler(): SvelteCompiler;

package/templates/static/lib/compilers/svelte.js

@@ -18,44 +18,44 @@
 import { compile as svelteCompile } from "svelte/compiler";
 import { log } from "../shared/log.js";
 export class SvelteCompiler {
-    compile(source, options) {
-        try {
-            const filename = options.filename || "component.svelte";
-            const result = svelteCompile(source, {
-                filename,
-                dev: options.dev ?? false,
-                hydratable: options.hydratable ?? false,
-                css: "injected", // Inject CSS at runtime instead of extracting
-                preserveComments: !options.minified,
-                preserveWhitespace: !options.minified,
-            });
-            if (result.warnings && result.warnings.length > 0) {
-                result.warnings.forEach((w) => {
-                    log.warn(`[Svelte] ${filename}: ${w.message}`);
-                });
-            }
-            // Build module code
-            let code = result.js.code;
-            // If CSS is generated, inject it
-            if (result.css && result.css.code.trim()) {
-                const escapedCss = result.css.code.replace(/"/g, '\\"').replace(/\n/g, "\\n");
-                code += `
+  compile(source, options) {
+    try {
+      const filename = options.filename || "component.svelte";
+      const result = svelteCompile(source, {
+        filename,
+        dev: options.dev ?? false,
+        css: "injected", // Inject CSS at runtime instead of extracting
+        preserveComments: !options.minified,
+        preserveWhitespace: !options.minified,
+      });
+      if (result.warnings && result.warnings.length > 0) {
+        result.warnings.forEach((w) => {
+          log.warn(`[Svelte] ${filename}: ${w.message}`);
+        });
+      }
+      // Build module code
+      let code = result.js.code;
+      // If CSS is generated, inject it
+      if (result.css && result.css.code.trim()) {
+        const escapedCss = result.css.code
+          .replace(/"/g, '\\"')
+          .replace(/\n/g, "\\n");
+        code += `
 if (typeof window !== 'undefined') {
   const style = document.createElement('style');
   style.textContent = "${escapedCss}";
   document.head.appendChild(style);
 }
 `;
-            }
-            return { code };
-        }
-        catch (err) {
-            const message = err.message || String(err);
-            log.error(`[Svelte] Compilation error: ${message}`);
-            return { code: "", error: message };
-        }
+      }
+      return { code };
+    } catch (err) {
+      const message = err.message || String(err);
+      log.error(`[Svelte] Compilation error: ${message}`);
+      return { code: "", error: message };
     }
+  }
 }
 export function createSvelteCompiler() {
-    return new SvelteCompiler();
+  return new SvelteCompiler();
 }

package/templates/static/lib/compilers/vue.d.ts

@@ -1,15 +1,15 @@
 export interface VueCompileOptions {
-    id?: string;
-    filename?: string;
-    minified?: boolean;
-    sourceMap?: boolean;
+  id?: string;
+  filename?: string;
+  minified?: boolean;
+  sourceMap?: boolean;
 }
 export interface VueCompileResult {
-    code: string;
-    bindings?: Record<string, any>;
-    error?: string;
+  code: string;
+  bindings?: Record<string, any>;
+  error?: string;
 }
 export declare class VueCompiler {
-    compile(source: string, options: VueCompileOptions): VueCompileResult;
+  compile(source: string, options: VueCompileOptions): VueCompileResult;
 }
 export declare function createVueCompiler(): VueCompiler;

package/templates/static/lib/compilers/vue.js

@@ -15,85 +15,93 @@
  * You should have received a copy of the GNU General Public License
  * along with this program. If not, see <https://www.gnu.org/licenses/>.
  */
-import { parse, compileScript, compileTemplate, compileStyle } from "@vue/compiler-sfc";
+import {
+  parse,
+  compileScript,
+  compileTemplate,
+  compileStyle,
+} from "@vue/compiler-sfc";
 import { log } from "../shared/log.js";
 export class VueCompiler {
-    compile(source, options) {
-        try {
-            const filename = options.filename || "component.vue";
-            const id = options.id || filename.replace(/[^a-z0-9]/gi, "_");
-            // Parse SFC
-            const parseResult = parse(source, { filename });
-            const descriptor = parseResult.descriptor;
-            let scriptCode = "";
-            let templateCode = "";
-            let styleCode = "";
-            // Compile script
-            if (descriptor.script || descriptor.scriptSetup) {
-                const scriptCompiled = compileScript(descriptor, {
-                    id,
-                    isProd: options.minified ?? false,
-                });
-                scriptCode = scriptCompiled.content;
-            }
-            // Compile template
-            if (descriptor.template) {
-                const templateCompiled = compileTemplate({
-                    source: descriptor.template.content,
-                    filename,
-                    id,
-                    compilerOptions: {
-                        isCustomElement: (tag) => tag.startsWith("custom-"),
-                    },
-                });
-                if (templateCompiled.errors.length > 0) {
-                    return {
-                        code: "",
-                        error: `Template compilation error: ${templateCompiled.errors.join(", ")}`,
-                    };
-                }
-                templateCode = templateCompiled.code;
-            }
-            // Compile styles (scoped)
-            if (descriptor.styles.length > 0) {
-                descriptor.styles.forEach((style, idx) => {
-                    const styleCompiled = compileStyle({
-                        source: style.content,
-                        filename,
-                        id,
-                        scoped: style.scoped ?? false,
-                    });
-                    if (styleCompiled.errors.length > 0) {
-                        log.warn(`Style compilation warning at style[${idx}]: ${styleCompiled.errors.join(", ")}`);
-                    }
-                    styleCode += styleCompiled.code + "\n";
-                });
-            }
-            // Inject styles at runtime
-            let injectStyle = "";
-            if (styleCode.trim()) {
-                const escapedStyle = styleCode.replace(/"/g, '\\"').replace(/\n/g, "\\n");
-                injectStyle = `
+  compile(source, options) {
+    try {
+      const filename = options.filename || "component.vue";
+      const id = options.id || filename.replace(/[^a-z0-9]/gi, "_");
+      // Parse SFC
+      const parseResult = parse(source, { filename });
+      const descriptor = parseResult.descriptor;
+      let scriptCode = "";
+      let templateCode = "";
+      let styleCode = "";
+      // Compile script
+      if (descriptor.script || descriptor.scriptSetup) {
+        const scriptCompiled = compileScript(descriptor, {
+          id,
+          isProd: options.minified ?? false,
+        });
+        scriptCode = scriptCompiled.content;
+      }
+      // Compile template
+      if (descriptor.template) {
+        const templateCompiled = compileTemplate({
+          source: descriptor.template.content,
+          filename,
+          id,
+          compilerOptions: {
+            isCustomElement: (tag) => tag.startsWith("custom-"),
+          },
+        });
+        if (templateCompiled.errors.length > 0) {
+          return {
+            code: "",
+            error: `Template compilation error: ${templateCompiled.errors.join(", ")}`,
+          };
+        }
+        templateCode = templateCompiled.code;
+      }
+      // Compile styles (scoped)
+      if (descriptor.styles.length > 0) {
+        descriptor.styles.forEach((style, idx) => {
+          const styleCompiled = compileStyle({
+            source: style.content,
+            filename,
+            id,
+            scoped: style.scoped ?? false,
+          });
+          if (styleCompiled.errors.length > 0) {
+            log.warn(
+              `Style compilation warning at style[${idx}]: ${styleCompiled.errors.join(", ")}`,
+            );
+          }
+          styleCode += styleCompiled.code + "\n";
+        });
+      }
+      // Inject styles at runtime
+      let injectStyle = "";
+      if (styleCode.trim()) {
+        const escapedStyle = styleCode
+          .replace(/"/g, '\\"')
+          .replace(/\n/g, "\\n");
+        injectStyle = `
 const style = document.createElement('style');
 style.textContent = "${escapedStyle}";
 document.head.appendChild(style);
 `;
-            }
-            // Build final module
-            const finalCode = `
+      }
+      // Build final module
+      const finalCode = `
 ${scriptCode || "export default {}"}
 ${templateCode}
 ${injectStyle}
 `;
-            return { code: finalCode };
-        }
-        catch (err) {
-            const message = err.message || String(err);
-            log.error(`[Vue] Compilation error: ${message}`);
-            return { code: "", error: message };
-        }
+      return { code: finalCode };
+    } catch (err) {
+      const message = err.message || String(err);
+      log.error(`[Vue] Compilation error: ${message}`);
+      return { code: "", error: message };
     }
+  }
 }
 export function createVueCompiler() {
-    return new VueCompiler();
+  return new VueCompiler();
 }