create-athenea-app 0.1.1

package/README.md

@@ -0,0 +1,19 @@
+# create-athenea-app
+
+Paquete CLI para generar un proyecto basado en esta plantilla.
+
+Uso (cuando este publicado):
+
+```bash
+npm create athenea-app@latest
+```
+
+Tambien podes pasar el nombre directo:
+
+```bash
+npm create athenea-app@latest mi-proyecto
+```
+
+Opciones:
+
+- `--no-install`: no ejecuta `npm install`

package/bin/index.js

@@ -0,0 +1,314 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+import fsp from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { createInterface } from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import { spawn } from "node:child_process";
+import zlib from "node:zlib";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+function printHelp() {
+  console.log(
+    [
+      "create-athenea-app",
+      "",
+      "Uso:",
+      "  npm create athenea-app@latest [nombre]",
+      "",
+      "Opciones:",
+      "  --no-install   No ejecuta npm install",
+      "  --help         Muestra esta ayuda",
+    ].join("\n"),
+  );
+}
+
+function slugify(inputText) {
+  const s = String(inputText)
+    .normalize("NFKD")
+    .replace(/[\u0300-\u036f]/g, "")
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "");
+
+  return s;
+}
+
+function assertEmptyDir(dirPath) {
+  if (!fs.existsSync(dirPath)) return;
+  const entries = fs.readdirSync(dirPath);
+  if (entries.length > 0) {
+    throw new Error(`La carpeta ya existe y no esta vacia: ${dirPath}`);
+  }
+}
+
+async function replaceTokensInFile(filePath, tokenMap) {
+  let content = await fsp.readFile(filePath, "utf8");
+  for (const [token, value] of Object.entries(tokenMap)) {
+    content = content.split(token).join(value);
+  }
+  await fsp.writeFile(filePath, content, "utf8");
+}
+
+async function updateAppPackageJson(
+  projectDir,
+  { npmName, productName, appId },
+) {
+  const pkgPath = path.join(projectDir, "package.json");
+  const raw = await fsp.readFile(pkgPath, "utf8");
+  const pkg = JSON.parse(raw);
+
+  pkg.name = npmName;
+  if (typeof pkg.version !== "string") pkg.version = "0.1.0";
+
+  if (!pkg.build || typeof pkg.build !== "object") pkg.build = {};
+  pkg.build.productName = productName;
+  pkg.build.appId = appId;
+
+  await fsp.writeFile(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf8");
+}
+
+// ---------- Asset generator (white placeholders) ----------
+function crc32(buf) {
+  let crc = 0 ^ -1;
+  for (let i = 0; i < buf.length; i++) {
+    crc ^= buf[i];
+    for (let j = 0; j < 8; j++) {
+      const mask = -(crc & 1);
+      crc = (crc >>> 1) ^ (0xedb88320 & mask);
+    }
+  }
+  return (crc ^ -1) >>> 0;
+}
+
+function pngSolidRGBA(width, height, r, g, b, a) {
+  const signature = Buffer.from([
+    0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a,
+  ]);
+
+  const ihdrData = Buffer.alloc(13);
+  ihdrData.writeUInt32BE(width, 0);
+  ihdrData.writeUInt32BE(height, 4);
+  ihdrData[8] = 8; // bit depth
+  ihdrData[9] = 6; // color type RGBA
+  ihdrData[10] = 0; // compression
+  ihdrData[11] = 0; // filter
+  ihdrData[12] = 0; // interlace
+
+  function chunk(type, data) {
+    const typeBuf = Buffer.from(type, "ascii");
+    const lenBuf = Buffer.alloc(4);
+    lenBuf.writeUInt32BE(data.length, 0);
+    const crcBuf = Buffer.alloc(4);
+    const crc = crc32(Buffer.concat([typeBuf, data]));
+    crcBuf.writeUInt32BE(crc, 0);
+    return Buffer.concat([lenBuf, typeBuf, data, crcBuf]);
+  }
+
+  const row = Buffer.alloc(1 + width * 4);
+  row[0] = 0; // filter type 0
+  for (let x = 0; x < width; x++) {
+    const o = 1 + x * 4;
+    row[o + 0] = r;
+    row[o + 1] = g;
+    row[o + 2] = b;
+    row[o + 3] = a;
+  }
+
+  const raw = Buffer.alloc(row.length * height);
+  for (let y = 0; y < height; y++) row.copy(raw, y * row.length);
+
+  const compressed = zlib.deflateSync(raw, { level: 9 });
+
+  return Buffer.concat([
+    signature,
+    chunk("IHDR", ihdrData),
+    chunk("IDAT", compressed),
+    chunk("IEND", Buffer.alloc(0)),
+  ]);
+}
+
+function icoFromPng(pngBuf, size) {
+  const header = Buffer.alloc(6);
+  header.writeUInt16LE(0, 0); // reserved
+  header.writeUInt16LE(1, 2); // type icon
+  header.writeUInt16LE(1, 4); // count
+
+  const entry = Buffer.alloc(16);
+  entry.writeUInt8(size === 256 ? 0 : size, 0); // width
+  entry.writeUInt8(size === 256 ? 0 : size, 1); // height
+  entry.writeUInt8(0, 2); // color count
+  entry.writeUInt8(0, 3); // reserved
+  entry.writeUInt16LE(1, 4); // planes
+  entry.writeUInt16LE(32, 6); // bit count
+  entry.writeUInt32LE(pngBuf.length, 8); // bytes in res
+  entry.writeUInt32LE(6 + 16, 12); // offset
+
+  return Buffer.concat([header, entry, pngBuf]);
+}
+
+function bmpSolid24(width, height, r, g, b) {
+  const rowSize = (width * 3 + 3) & ~3; // 4-byte aligned
+  const pixelDataSize = rowSize * height;
+  const fileSize = 14 + 40 + pixelDataSize;
+
+  const fileHeader = Buffer.alloc(14);
+  fileHeader.write("BM", 0, 2, "ascii");
+  fileHeader.writeUInt32LE(fileSize, 2);
+  fileHeader.writeUInt32LE(0, 6);
+  fileHeader.writeUInt32LE(14 + 40, 10);
+
+  const dib = Buffer.alloc(40);
+  dib.writeUInt32LE(40, 0); // header size
+  dib.writeInt32LE(width, 4);
+  dib.writeInt32LE(height, 8); // bottom-up
+  dib.writeUInt16LE(1, 12); // planes
+  dib.writeUInt16LE(24, 14); // bpp
+  dib.writeUInt32LE(0, 16); // BI_RGB
+  dib.writeUInt32LE(pixelDataSize, 20);
+  dib.writeInt32LE(2835, 24); // 72 DPI
+  dib.writeInt32LE(2835, 28);
+  dib.writeUInt32LE(0, 32);
+  dib.writeUInt32LE(0, 36);
+
+  const pixels = Buffer.alloc(pixelDataSize);
+  for (let y = 0; y < height; y++) {
+    const rowOff = y * rowSize;
+    for (let x = 0; x < width; x++) {
+      const o = rowOff + x * 3;
+      pixels[o + 0] = b;
+      pixels[o + 1] = g;
+      pixels[o + 2] = r;
+    }
+    // padding queda en 0
+  }
+
+  return Buffer.concat([fileHeader, dib, pixels]);
+}
+
+async function ensureWhiteBuildAssets(projectDir) {
+  const assetsDir = path.join(projectDir, "assets");
+  const publicDir = path.join(projectDir, "public");
+  await fsp.mkdir(assetsDir, { recursive: true });
+  await fsp.mkdir(publicDir, { recursive: true });
+
+  const png256 = pngSolidRGBA(256, 256, 255, 255, 255, 255);
+  const ico = icoFromPng(png256, 256);
+  await fsp.writeFile(path.join(assetsDir, "build.ico"), ico);
+
+  await fsp.writeFile(
+    path.join(assetsDir, "installer-sidebar.bmp"),
+    bmpSolid24(164, 314, 255, 255, 255),
+  );
+  await fsp.writeFile(
+    path.join(assetsDir, "installer-header.bmp"),
+    bmpSolid24(150, 57, 255, 255, 255),
+  );
+
+  const viteSvgPath = path.join(publicDir, "vite.svg");
+  if (!fs.existsSync(viteSvgPath)) {
+    const svg =
+      '<?xml version="1.0" encoding="UTF-8"?>\n' +
+      '<svg xmlns="http://www.w3.org/2000/svg" width="64" height="64" viewBox="0 0 64 64">\n' +
+      '  <rect width="64" height="64" fill="#ffffff"/>\n' +
+      "</svg>\n";
+    await fsp.writeFile(viteSvgPath, svg, "utf8");
+  }
+}
+
+async function npmInstall(projectDir) {
+  const isWin = process.platform === "win32";
+  const npmCmd = isWin ? "npm.cmd" : "npm";
+
+  await new Promise((resolve, reject) => {
+    const child = spawn(npmCmd, ["install"], {
+      cwd: projectDir,
+      stdio: "inherit",
+      shell: isWin,
+    });
+    child.on("close", (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(`npm install fallo con codigo ${code}`));
+    });
+    child.on("error", reject);
+  });
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  if (args.includes("--help") || args.includes("-h")) {
+    printHelp();
+    return;
+  }
+
+  const noInstall = args.includes("--no-install");
+  const nameArg = args.find((a) => a && !a.startsWith("-"));
+
+  let projectName = nameArg;
+  if (!projectName) {
+    const rl = createInterface({ input, output });
+    projectName = (await rl.question("Nombre del proyecto: ")).trim();
+    await rl.close();
+  }
+
+  if (!projectName) {
+    console.error("Nombre requerido.");
+    process.exit(1);
+  }
+
+  const productName = projectName.trim();
+  const npmName = slugify(productName);
+  if (!npmName) {
+    console.error("Nombre invalido: no se pudo generar un nombre de paquete.");
+    process.exit(1);
+  }
+
+  const appId = `com.example.${npmName}`;
+  const targetDir = path.resolve(process.cwd(), npmName);
+  assertEmptyDir(targetDir);
+
+  const templateDir = path.resolve(__dirname, "..", "template");
+  await fsp.mkdir(targetDir, { recursive: true });
+  await fsp.cp(templateDir, targetDir, { recursive: true });
+
+  await updateAppPackageJson(targetDir, { npmName, productName, appId });
+
+  const tokenMap = {
+    __APP_TITLE__: productName,
+    __APP_TITLE_JSON__: JSON.stringify(productName),
+    __APP_APP_ID__: appId,
+  };
+
+  await Promise.all([
+    replaceTokensInFile(path.join(targetDir, "electron.js"), tokenMap),
+    replaceTokensInFile(path.join(targetDir, "index.html"), tokenMap),
+    replaceTokensInFile(path.join(targetDir, "README.md"), tokenMap),
+    replaceTokensInFile(
+      path.join(targetDir, "src", "routes", "Home", "Home.jsx"),
+      tokenMap,
+    ),
+  ]);
+
+  await ensureWhiteBuildAssets(targetDir);
+
+  console.log("");
+  console.log(`Proyecto creado en: ${targetDir}`);
+  console.log("");
+  console.log("Siguientes pasos:");
+  console.log(`  cd ${npmName}`);
+  console.log("  npm run dev:electron");
+
+  if (!noInstall) {
+    console.log("");
+    console.log("Instalando dependencias...");
+    await npmInstall(targetDir);
+  }
+}
+
+main().catch((err) => {
+  console.error("[create-athenea-app] Error:", err?.message || err);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "create-athenea-app",
+  "version": "0.1.1",
+  "type": "module",
+  "description": "Creador de proyectos Athenea (Electron + Preact + Vite)",
+  "keywords": [
+    "create",
+    "starter",
+    "template",
+    "electron",
+    "preact",
+    "vite"
+  ],
+  "bin": {
+    "create-athenea-app": "bin/index.js"
+  },
+  "files": [
+    "bin",
+    "template"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT"
+}

package/template/README.md

@@ -0,0 +1,19 @@
+# **APP_TITLE**
+
+Proyecto generado con `create-athenea-app`.
+
+## Scripts
+
+```bash
+npm run dev:electron
+npm run build
+npm run pack
+npm run dist
+```
+
+## Branding
+
+- Nombre del instalador/app: `package.json` -> `build.productName`
+- ID de la app: `package.json` -> `build.appId`
+- Titulos: `electron.js` y `index.html`
+- Recursos de instalador (placeholders blancos): `assets/build.ico` y `assets/installer-*.bmp`

package/template/electron.js

@@ -0,0 +1,230 @@
+import { app, BrowserWindow, ipcMain, dialog, screen } from "electron";
+import path from "path";
+import { fileURLToPath } from "url";
+import fs from "fs";
+import os from "os";
+import keytar from "keytar";
+import pdfPrinter from "pdf-to-printer";
+import { spawn } from "child_process";
+import log from "electron-log";
+
+// Inicializar logger
+log.initialize();
+log.transports.file.level = "info";
+log.info("Iniciando aplicacion...");
+
+const { print: printPDF, getPrinters } = pdfPrinter;
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+app.commandLine.appendSwitch("disable-features", "Autofill");
+if (!app.isPackaged || process.env.ELECTRON_DISABLE_SANDBOX === "1") {
+  app.commandLine.appendSwitch("no-sandbox");
+}
+
+let backendProcess = null;
+
+function getBackendPath() {
+  const isWin = process.platform === "win32";
+  const executableName = isWin
+    ? "api_billing_software.exe"
+    : "api_billing_software";
+
+  if (app.isPackaged) {
+    return path.join(
+      process.resourcesPath,
+      "api_billing_software",
+      executableName,
+    );
+  }
+
+  return path.join(
+    __dirname,
+    "..",
+    "backend",
+    "dist",
+    "api_billing_software",
+    executableName,
+  );
+}
+
+function startBackend() {
+  const backendPath = getBackendPath();
+  log.info("Intentando iniciar backend desde:", backendPath);
+
+  if (!fs.existsSync(backendPath)) {
+    log.error("No se encontro el ejecutable del backend en:", backendPath);
+    return;
+  }
+
+  backendProcess = spawn(backendPath, [], {
+    cwd: path.dirname(backendPath),
+    stdio: "pipe",
+    windowsHide: true,
+  });
+
+  backendProcess.on("close", () => {
+    backendProcess = null;
+  });
+}
+
+function stopBackend() {
+  if (backendProcess) {
+    backendProcess.kill();
+    backendProcess = null;
+  }
+}
+
+/** @type {BrowserWindow | null} */
+let mainWindow = null;
+
+/** @type {Map<string, BrowserWindow>} */
+const childWindowsByRoute = new Map();
+
+const settingsPath = path.join(app.getPath("userData"), "settings.json");
+
+function createWindow() {
+  const isDev = !app.isPackaged;
+  const devServerUrl = process.env.DEV_SERVER_URL || "http://localhost:5171";
+  const { width: screenWidth, height: screenHeight } =
+    screen.getPrimaryDisplay().workAreaSize;
+
+  mainWindow = new BrowserWindow({
+    width: screenWidth,
+    height: screenHeight,
+    title: __APP_TITLE_JSON__,
+    webPreferences: {
+      preload: path.join(__dirname, "preload.cjs"),
+      devTools: isDev,
+      contextIsolation: true,
+      nodeIntegration: false,
+    },
+  });
+
+  mainWindow.setMenuBarVisibility(false);
+  mainWindow.setAutoHideMenuBar(true);
+  mainWindow.maximize();
+
+  if (isDev) {
+    mainWindow.loadURL(devServerUrl);
+    mainWindow.webContents.openDevTools();
+  } else {
+    const indexPath = path.join(__dirname, "dist", "index.html");
+    mainWindow.loadFile(indexPath, { query: { route: "/" } });
+  }
+
+  mainWindow.on("minimize", () => {
+    for (const [, child] of childWindowsByRoute) {
+      if (!child.isDestroyed() && !child.isMinimized()) child.minimize();
+    }
+  });
+
+  mainWindow.on("restore", () => {
+    for (const [, child] of childWindowsByRoute) {
+      if (!child.isDestroyed()) child.restore();
+    }
+  });
+}
+
+app.whenReady().then(() => {
+  startBackend();
+  createWindow();
+});
+
+app.on("will-quit", () => {
+  stopBackend();
+});
+
+app.on("window-all-closed", () => {
+  if (process.platform !== "darwin") app.quit();
+});
+
+app.on("activate", () => {
+  if (BrowserWindow.getAllWindows().length === 0) createWindow();
+});
+
+function readSettings() {
+  try {
+    if (!fs.existsSync(settingsPath)) return {};
+    return JSON.parse(fs.readFileSync(settingsPath, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+
+function writeSettings(data) {
+  try {
+    fs.writeFileSync(settingsPath, JSON.stringify(data, null, 2), "utf-8");
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+ipcMain.handle("settings:get", () => readSettings());
+ipcMain.handle("settings:set", (_event, data) => {
+  const current = readSettings();
+  const merged = { ...current, ...data };
+  writeSettings(merged);
+  return merged;
+});
+
+ipcMain.handle("printer:getPrinters", async () => {
+  return await getPrinters();
+});
+ipcMain.handle("printer:printPDF", async (_event, { filePath, options }) => {
+  try {
+    await printPDF(filePath, options || {});
+    return { ok: true };
+  } catch (err) {
+    return { ok: false, error: err?.message || String(err) };
+  }
+});
+
+ipcMain.on("window:openRoute", (_event, options) => {
+  const route = typeof options === "string" ? options : options?.route;
+  const title = typeof options === "object" ? options.title : null;
+  if (!route) return;
+
+  const routeKey = String(route);
+  const existing = childWindowsByRoute.get(routeKey);
+  if (existing && !existing.isDestroyed()) {
+    if (existing.isMinimized()) existing.restore();
+    existing.focus();
+    return;
+  }
+
+  const isDev = !app.isPackaged;
+  const devServerUrl = process.env.DEV_SERVER_URL || "http://localhost:5171";
+  const preloadPath = path.join(__dirname, "preload.cjs");
+
+  const child = new BrowserWindow({
+    width: 1200,
+    height: 700,
+    title: title || __APP_TITLE_JSON__,
+    webPreferences: {
+      preload: preloadPath,
+      devTools: isDev,
+      contextIsolation: true,
+      nodeIntegration: false,
+    },
+  });
+
+  child.setMenuBarVisibility(false);
+  child.setAutoHideMenuBar(true);
+  if (mainWindow && !mainWindow.isDestroyed())
+    child.setParentWindow(mainWindow);
+  childWindowsByRoute.set(routeKey, child);
+
+  if (isDev) {
+    child.loadURL(`${devServerUrl}?route=${encodeURIComponent(route)}&child=1`);
+    child.webContents.openDevTools();
+  } else {
+    const indexPath = path.join(__dirname, "dist", "index.html");
+    child.loadFile(indexPath, { query: { route, child: "1" } });
+  }
+
+  child.on("closed", () => {
+    const current = childWindowsByRoute.get(routeKey);
+    if (current === child) childWindowsByRoute.delete(routeKey);
+  });
+});

package/template/eslint.config.js

@@ -0,0 +1,3 @@
+import js from "@eslint/js";
+
+export default [js.configs.recommended];

package/template/index.html

@@ -0,0 +1,13 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="vite.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>__APP_TITLE__</title>
+  </head>
+  <body>
+    <div id="app"></div>
+    <script type="module" src="src/main.jsx"></script>
+  </body>
+</html>

package/template/package.json

@@ -0,0 +1,123 @@
+{
+  "name": "__APP_TITLE__",
+  "private": true,
+  "version": "0.1.1",
+  "type": "module",
+  "main": "electron.js",
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "scripts": {
+    "dev": "vite --host --port 0",
+    "electron": "cross-env NODE_OPTIONS=\"--experimental-require-module --no-warnings\" electron .",
+    "dev:electron": "node scripts/dev-electron.mjs",
+    "copy-preload": "node -e \"const fs=require('fs'); if(!fs.existsSync('dist')) fs.mkdirSync('dist'); fs.copyFileSync('preload.cjs','dist/preload.cjs')\"",
+    "build": "vite build && npm run copy-preload",
+    "preview": "vite preview",
+    "pack": "npm run build && electron-builder --dir",
+    "dist": "npm run build && electron-builder",
+    "dist:linux": "npm run build && electron-builder --linux",
+    "dist:win": "npm run build && electron-builder --win",
+    "lint": "eslint .",
+    "format": "prettier --write .",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest",
+    "postinstall": "electron-builder install-app-deps"
+  },
+  "dependencies": {
+    "@preact/signals": "^2.5.1",
+    "@tanstack/react-table": "^8.21.3",
+    "dayjs": "^1.11.13",
+    "electron-log": "^5.4.3",
+    "electron-updater": "^6.6.2",
+    "jwt-decode": "^4.0.0",
+    "keytar": "7.9.0",
+    "ky": "^1.2.4",
+    "pdf-to-printer": "5.6.1",
+    "preact": "^10.26.2",
+    "preact-iso": "^2.9.1",
+    "sweetalert2": "^11.26.10",
+    "zod": "^3.23.8",
+    "zustand": "^5.0.3"
+  },
+  "devDependencies": {
+    "@eslint/eslintrc": "^3.3.1",
+    "@eslint/js": "^9.39.1",
+    "@preact/preset-vite": "^2.10.1",
+    "@testing-library/preact": "3.2.3",
+    "@types/node": "^22.7.8",
+    "@typescript-eslint/eslint-plugin": "^8.46.4",
+    "@typescript-eslint/parser": "^8.46.4",
+    "autoprefixer": "^10.4.20",
+    "concurrently": "^8.2.0",
+    "cross-env": "^7.0.3",
+    "dotenv": "^16.4.5",
+    "electron": "^35.1.4",
+    "electron-builder": "^24.13.1",
+    "eslint": "^9.39.1",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-prettier": "^5.5.4",
+    "eslint-plugin-react-hooks": "^7.0.1",
+    "postcss": "^8.4.47",
+    "prettier": "^3.6.2",
+    "tailwindcss": "^3.4.14",
+    "typescript": "^5.9.3",
+    "vite": "^7.2.2",
+    "vite-tsconfig-paths": "^5.0.0",
+    "vitest": "^4.0.8",
+    "wait-on": "^7.0.1"
+  },
+  "overrides": {
+    "tar": "7.5.7"
+  },
+  "build": {
+    "appId": "__APP_APP_ID__",
+    "productName": "__APP_TITLE__",
+    "asar": true,
+    "asarUnpack": [
+      "**/*.node",
+      "preload.cjs",
+      "node_modules/pdf-to-printer/**/*"
+    ],
+    "directories": {
+      "buildResources": "assets",
+      "output": "../release"
+    },
+    "extraResources": [],
+    "files": [
+      "dist/**/*",
+      "electron.js",
+      "preload.cjs",
+      "!**/*.map",
+      "!**/node_modules/*/{CHANGELOG.md,README.md,README,readme.md,readme}",
+      "!**/node_modules/*/{test,__tests__,tests,powered-test,example,examples}"
+    ],
+    "win": {
+      "target": [
+        "nsis"
+      ],
+      "signAndEditExecutable": false,
+      "icon": "assets/build.ico"
+    },
+    "nsis": {
+      "oneClick": false,
+      "perMachine": true,
+      "allowToChangeInstallationDirectory": true,
+      "createDesktopShortcut": true,
+      "createStartMenuShortcut": true,
+      "installerIcon": "assets/build.ico",
+      "uninstallerIcon": "assets/build.ico",
+      "installerSidebar": "assets/installer-sidebar.bmp",
+      "uninstallerSidebar": "assets/installer-sidebar.bmp",
+      "installerHeader": "assets/installer-header.bmp"
+    },
+    "linux": {
+      "target": [
+        "AppImage",
+        "deb"
+      ],
+      "category": "Office",
+      "maintainer": "tu-email@ejemplo.com"
+    }
+  }
+}

package/template/preload.cjs

@@ -0,0 +1,9 @@
+const { contextBridge, ipcRenderer } = require("electron");
+
+contextBridge.exposeInMainWorld("electronAPI", {
+  settingsGet: () => ipcRenderer.invoke("settings:get"),
+  settingsSet: (data) => ipcRenderer.invoke("settings:set", data),
+  openRoute: (options) => ipcRenderer.send("window:openRoute", options),
+  getPrinters: () => ipcRenderer.invoke("printer:getPrinters"),
+  printPDF: (payload) => ipcRenderer.invoke("printer:printPDF", payload),
+});

package/template/preload.js

@@ -0,0 +1 @@
+// Compat (si alguien lo usa desde ESM). El preload real es preload.cjs

package/template/public/logo.svg

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg xmlns="http://www.w3.org/2000/svg" width="256" height="256" viewBox="0 0 256 256">
+	<rect width="256" height="256" fill="#ffffff"/>
+</svg>

package/template/scripts/dev-electron.mjs

@@ -0,0 +1,71 @@
+import { createServer } from "vite";
+import { spawn } from "child_process";
+import path from "path";
+import { fileURLToPath } from "url";
+import fs from "fs";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+async function start() {
+  const server = await createServer({
+    server: {
+      host: "127.0.0.1",
+      port: 0,
+    },
+  });
+
+  await server.listen();
+
+  const url =
+    server.resolvedUrls?.local?.[0] ||
+    `http://localhost:${server.config.server.port || 5173}`;
+
+  console.log(`[dev-electron] Vite dev server en ${url}`);
+
+  const isWin = process.platform === "win32";
+  const localElectronBin = path.resolve(
+    __dirname,
+    "..",
+    "node_modules",
+    ".bin",
+    isWin ? "electron.cmd" : "electron",
+  );
+  const electronBin = fs.existsSync(localElectronBin)
+    ? localElectronBin
+    : "electron";
+
+  const electronProcess = spawn(electronBin, [".", "--no-sandbox"], {
+    stdio: "inherit",
+    shell: isWin,
+    env: {
+      ...process.env,
+      DEV_SERVER_URL: url,
+      NODE_OPTIONS: "--experimental-require-module --no-warnings",
+      ELECTRON_DISABLE_SANDBOX: "1",
+    },
+    cwd: path.resolve(__dirname, ".."),
+  });
+
+  const clean = () => {
+    electronProcess.kill();
+    server.close();
+  };
+
+  electronProcess.on("close", (code) => {
+    clean();
+    process.exit(code ?? 0);
+  });
+
+  const handleSignal = () => {
+    clean();
+    process.exit(0);
+  };
+
+  process.on("SIGINT", handleSignal);
+  process.on("SIGTERM", handleSignal);
+}
+
+start().catch((err) => {
+  console.error("[dev-electron] Error:", err);
+  process.exit(1);
+});

package/template/src/components/Counter/Counter.jsx

@@ -0,0 +1,13 @@
+import { useState } from "preact/hooks";
+import "./style.css";
+
+export function Counter() {
+  const [count, setCount] = useState(0);
+  return (
+    <div className="counter">
+      <button onClick={() => setCount((c) => c - 1)}>-</button>
+      <span>{count}</span>
+      <button onClick={() => setCount((c) => c + 1)}>+</button>
+    </div>
+  );
+}

package/template/src/components/Counter/style.css

@@ -0,0 +1,9 @@
+.counter {
+  display: inline-flex;
+  gap: 12px;
+  align-items: center;
+}
+
+.counter button {
+  padding: 8px 12px;
+}

package/template/src/index.css

@@ -0,0 +1,7 @@
+:root {
+  font-family: system-ui, sans-serif;
+}
+
+body {
+  margin: 0;
+}

package/template/src/main.jsx

@@ -0,0 +1,16 @@
+import { render } from "preact";
+import { LocationProvider, Router, Route } from "preact-iso";
+import Home from "./routes/Home/Home";
+import "./index.css";
+
+function App() {
+  return (
+    <LocationProvider>
+      <Router>
+        <Route path="/" component={Home} />
+      </Router>
+    </LocationProvider>
+  );
+}
+
+render(<App />, document.getElementById("app"));

package/template/src/routes/Home/Home.jsx

@@ -0,0 +1,12 @@
+import { Counter } from "../../components/Counter/Counter";
+import "./style.css";
+
+export default function Home() {
+  return (
+    <div className="home">
+      <h1 className="home-title">Bienvenido a __APP_TITLE__</h1>
+      <img className="home-logo" src="/logo.svg" alt="" />
+      <Counter />
+    </div>
+  );
+}

package/template/src/routes/Home/style.css

@@ -0,0 +1,13 @@
+.home {
+  min-height: 100vh;
+  display: grid;
+  place-content: center;
+  gap: 16px;
+  text-align: center;
+}
+
+.home-logo {
+  width: 120px;
+  height: 120px;
+  margin: 0 auto;
+}

package/template/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "useDefineForClassFields": true,
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "skipLibCheck": true,
+    "moduleResolution": "Bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true,
+    "jsx": "react-jsx",
+    "jsxImportSource": "preact",
+    "strict": true,
+    "types": ["node"]
+  },
+  "include": ["src"]
+}

package/template/vite.config.js

@@ -0,0 +1,25 @@
+import { defineConfig } from "vite";
+import preact from "@preact/preset-vite";
+import path from "path";
+
+export default defineConfig({
+  plugins: [preact()],
+  base: "./",
+  publicDir: "public",
+  build: {
+    outDir: "dist",
+    assetsDir: "assets",
+    rollupOptions: {
+      output: {
+        assetFileNames: "assets/[name].[hash][extname]",
+        chunkFileNames: "assets/[name].[hash].js",
+        entryFileNames: "assets/[name].[hash].js",
+      },
+    },
+  },
+  resolve: {
+    alias: {
+      "@": path.resolve(__dirname, "./src"),
+    },
+  },
+});