@cosider.construction/eapp 1.0.1 → 1.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cosider.construction/eapp",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "Project-local CLI for Electron + Vue ERP projects",
   "type": "module",
   "bin": {

package/src/index.js

@@ -39,28 +39,70 @@ Options:
   --help, -h   Show this help
 `;
 
+const MAIN_MENU = [
+  { label: 'Entity',  value: 'entity'  },
+  { label: 'View',    value: 'view'    },
+  { label: 'Module',  value: 'module'  },
+  { label: 'Menu',    value: 'menu'    },
+  { label: 'Config',  value: 'config'  },
+  { label: 'Pivot',   value: 'pivot'   },
+  { label: 'Layout',  value: 'layout'  },
+  { label: 'List',    value: 'list'    },
+  { label: 'Quit',    value: 'quit'    },
+];
+
 async function launchInteractive() {
-  console.log('');
-  console.log(chalk.bold.cyan('  eapp') + chalk.dim(' — what do you want to do?'));
-  console.log('');
-  const chosen = await radioLine('', [
-    { label: 'Entity',  value: 'entity'  },
-    { label: 'View',    value: 'view'    },
-    { label: 'Module',  value: 'module'  },
-    { label: 'Menu',    value: 'menu'    },
-    { label: 'Config',  value: 'config'  },
-    { label: 'Pivot',   value: 'pivot'   },
-    { label: 'Layout',  value: 'layout'  },
-    { label: 'List',    value: 'list'    },
-  ]);
-  console.log('');
-  if (chosen === 'list') {
-    await listModules();
+  let lastIdx = 0;
+
+  // eslint-disable-next-line no-constant-condition
+  while (true) {
+    // Clear screen so each iteration feels fresh
+    process.stdout.write('\x1B[2J\x1B[H');
+    console.log('');
+    console.log(chalk.bold.cyan('  eapp') + chalk.dim(' — what do you want to do?'));
+    console.log(chalk.dim('  ← → select   enter confirm   Quit to exit'));
+
+    const chosen = await radioLine('', MAIN_MENU, lastIdx);
+    lastIdx = MAIN_MENU.findIndex(m => m.value === chosen);
+
     console.log('');
-    await listEntities([]);
-    return;
+
+    if (chosen === 'quit') {
+      console.log(chalk.dim('  Bye.\n'));
+      break;
+    }
+
+    if (chosen === 'list') {
+      await listModules();
+      console.log('');
+      await listEntities([]);
+    } else {
+      await run(chosen, [], []);
+    }
+
+    // Pause briefly so the user can read the result before the menu redraws
+    console.log('');
+    console.log(chalk.dim('  Press enter to return to the menu…'));
+    await waitEnter();
   }
-  await run(chosen, [], process.argv.slice(2));
+}
+
+function waitEnter() {
+  return new Promise((resolve) => {
+    process.stdin.resume();
+    process.stdin.setEncoding('utf8');
+    if (process.stdin.isTTY) process.stdin.setRawMode(true);
+    const onKey = (key) => {
+      if (key === '\r' || key === '\n' || key === '\x03') {
+        if (process.stdin.isTTY) process.stdin.setRawMode(false);
+        process.stdin.pause();
+        process.stdin.removeListener('data', onKey);
+        if (key === '\x03') process.exit(0);
+        resolve();
+      }
+    };
+    process.stdin.on('data', onKey);
+  });
 }
 
 async function run(command, args, rawArgs) {

package/src/tui/engine.js

@@ -10,42 +10,37 @@ import chalk from 'chalk';
 // ─── Raw input helpers ────────────────────────────────────────────────────────
 
 export function enableRawInput() {
-  if (process.stdin.isTTY) {
-    process.stdin.setRawMode(true);
-  }
+  if (process.stdin.isTTY) process.stdin.setRawMode(true);
   process.stdin.resume();
   process.stdin.setEncoding('utf8');
 }
 
 export function disableRawInput() {
-  if (process.stdin.isTTY) {
-    process.stdin.setRawMode(false);
-  }
+  if (process.stdin.isTTY) process.stdin.setRawMode(false);
   process.stdin.pause();
 }
 
 export function clearLines(n) {
-  for (let i = 0; i < n; i++) {
-    process.stdout.write('\x1B[1A\x1B[2K');
-  }
+  for (let i = 0; i < n; i++) process.stdout.write('\x1B[1A\x1B[2K');
 }
 
-export function hideCursor() { process.stdout.write('\x1B[?25l'); }
-export function showCursor() { process.stdout.write('\x1B[?25h'); }
+export function clearScreen() { process.stdout.write('\x1B[2J\x1B[H'); }
+export function hideCursor()  { process.stdout.write('\x1B[?25l'); }
+export function showCursor()  { process.stdout.write('\x1B[?25h'); }
 
 // ─── Key constants ────────────────────────────────────────────────────────────
 
 export const KEYS = {
-  UP:     '\x1B[A',
-  DOWN:   '\x1B[B',
-  RIGHT:  '\x1B[C',
-  LEFT:   '\x1B[D',
-  ENTER:  '\r',
-  SPACE:  ' ',
-  PLUS:   '+',
-  MINUS:  '-',
-  ESC:    '\x1B',
-  CTRL_C: '\x03',
+  UP:        '\x1B[A',
+  DOWN:      '\x1B[B',
+  RIGHT:     '\x1B[C',
+  LEFT:      '\x1B[D',
+  ENTER:     '\r',
+  SPACE:     ' ',
+  PLUS:      '+',
+  MINUS:     '-',
+  ESC:       '\x1B',
+  CTRL_C:    '\x03',
   BACKSPACE: '\x7F',
 };
 
@@ -65,8 +60,8 @@ export async function textInput(prompt, defaultVal = '') {
 // ─── Radio selector ───────────────────────────────────────────────────────────
 
 /**
- * Horizontal radio — one choice from options
- * Returns selected value
+ * Horizontal radio — one choice from options.
+ * Returns selected value.
  */
 export async function radioLine(prompt, options, defaultIdx = 0) {
   let selected = defaultIdx;
@@ -75,9 +70,7 @@ export async function radioLine(prompt, options, defaultIdx = 0) {
     process.stdout.clearLine?.(0);
     process.stdout.cursorTo?.(0);
     const opts = options.map((o, i) =>
-      i === selected
-        ? chalk.green(`◉ ${o.label}`)
-        : chalk.dim(`○ ${o.label}`)
+      i === selected ? chalk.green(`◉ ${o.label}`) : chalk.dim(`○ ${o.label}`)
     ).join('  ');
     process.stdout.write(`  ${chalk.cyan(prompt)}  ${opts}`);
   };
@@ -90,9 +83,9 @@ export async function radioLine(prompt, options, defaultIdx = 0) {
 
     const onKey = (key) => {
       if (key === KEYS.CTRL_C) { showCursor(); disableRawInput(); process.exit(0); }
-      if (key === KEYS.LEFT)  { selected = (selected - 1 + options.length) % options.length; render(); }
-      if (key === KEYS.RIGHT) { selected = (selected + 1) % options.length; render(); }
-      if (key === KEYS.ENTER) {
+      if (key === KEYS.LEFT)   { selected = (selected - 1 + options.length) % options.length; render(); }
+      if (key === KEYS.RIGHT)  { selected = (selected + 1) % options.length; render(); }
+      if (key === KEYS.ENTER)  {
         process.stdout.write('\n');
         process.stdin.removeListener('data', onKey);
         showCursor();
@@ -107,43 +100,46 @@ export async function radioLine(prompt, options, defaultIdx = 0) {
 // ─── Options toggles ──────────────────────────────────────────────────────────
 
 /**
- * One-line toggleable options
+ * One-line toggleable options.
  * Returns object { [key]: boolean }
  */
 export async function optionsLine(options) {
-  // options = [{ key, label, default }]
   const state = {};
   options.forEach(o => { state[o.key] = o.default !== false; });
   let cursor = 0;
 
-  const render = (lines = 1) => {
-    clearLines(lines);
-    const rendered = options.map((o, i) => {
-      const on = state[o.key];
-      const box = on ? chalk.green('◼') : chalk.dim('◻');
-      const label = i === cursor ? chalk.bold.white(o.label) : (on ? chalk.white(o.label) : chalk.dim(o.label));
+  // Lines: 1 (options row) + 1 (hint row) — always exactly 2
+  const RENDERED_LINES = 2;
+
+  const renderRow = () => {
+    return options.map((o, i) => {
+      const on    = state[o.key];
+      const box   = on ? chalk.green('◼') : chalk.dim('◻');
+      const label = i === cursor
+        ? chalk.bold.white(o.label)
+        : (on ? chalk.white(o.label) : chalk.dim(o.label));
       return `${box} ${label}`;
     }).join('  ');
-    console.log('  ' + rendered);
-    console.log(chalk.dim('  ← → navigate   space toggle   enter confirm'));
   };
 
   return new Promise((resolve) => {
     hideCursor();
     enableRawInput();
     console.log('');
-    const rendered = options.map((o) => {
-      const on = state[o.key];
-      return `${on ? chalk.green('◼') : chalk.dim('◻')} ${on ? chalk.white(o.label) : chalk.dim(o.label)}`;
-    }).join('  ');
-    console.log('  ' + rendered);
+    console.log('  ' + renderRow());
     console.log(chalk.dim('  ← → navigate   space toggle   enter confirm'));
 
     const onKey = (key) => {
       if (key === KEYS.CTRL_C) { showCursor(); disableRawInput(); process.exit(0); }
-      if (key === KEYS.LEFT)  { cursor = (cursor - 1 + options.length) % options.length; render(2); }
-      if (key === KEYS.RIGHT) { cursor = (cursor + 1) % options.length; render(2); }
-      if (key === KEYS.SPACE) { state[options[cursor].key] = !state[options[cursor].key]; render(2); }
+      if (key === KEYS.LEFT)   { cursor = (cursor - 1 + options.length) % options.length; }
+      if (key === KEYS.RIGHT)  { cursor = (cursor + 1) % options.length; }
+      if (key === KEYS.SPACE)  { state[options[cursor].key] = !state[options[cursor].key]; }
+      if (key === KEYS.LEFT || key === KEYS.RIGHT || key === KEYS.SPACE) {
+        clearLines(RENDERED_LINES);
+        console.log('  ' + renderRow());
+        console.log(chalk.dim('  ← → navigate   space toggle   enter confirm'));
+        return;
+      }
       if (key === KEYS.ENTER) {
         process.stdin.removeListener('data', onKey);
         showCursor();
@@ -157,72 +153,107 @@ export async function optionsLine(options) {
 
 // ─── Interactive table ────────────────────────────────────────────────────────
 
-const COL_WIDTHS = {
-  field:  18,
-  type:   10,
-  values: 14,
-  pk:      4,
-  fk:      4,
-  group:  14,
-};
-
 const FIELD_TYPES = ['varchar', 'int', 'decimal', 'date', 'datetime', 'bit', 'text', 'float', 'enum'];
 
-const AUDIT_COL_WIDTHS = { field: 20, type: 10 };
+// Columns where space toggles a boolean (rendered as ◼/◻ checkboxes)
+const BOOL_COLS = new Set(['pk', 'fk']);
+
+// Columns where space cycles between string values
+const CYCLE_COLS = {
+  vmenu: ['own', 'share'],
+  home:  ['on', 'off'],
+  grid:  ['on', 'off'],
+};
 
+// Strip ANSI escape codes to get the true printable length of a string.
+const ANSI_RE = /\x1B\[[0-9;]*m/g;
+function visibleLen(s) { return String(s).replace(ANSI_RE, '').length; }
+
+/**
+ * Pad or truncate str to exactly len visible characters.
+ * Too-long strings are cut with a trailing ellipsis so column borders stay aligned.
+ */
 function pad(str, len) {
-  const s = String(str ?? '');
-  return s.length >= len ? s.slice(0, len - 1) + ' ' : s + ' '.repeat(len - s.length);
+  const s  = String(str ?? '');
+  const vl = visibleLen(s);
+  if (vl === len) return s;
+  if (vl >  len)  return s.replace(ANSI_RE, '').slice(0, len - 1) + '…';
+  return s + ' '.repeat(len - vl);
 }
 
 function renderTableHeader(cols, widths) {
-  const header = cols.map(c => chalk.bold.cyan(pad(c, widths[c] || 12))).join(chalk.dim('│'));
+  const header  = cols.map(c => chalk.bold.cyan(pad(c, widths[c] || 12))).join(chalk.dim('│'));
   const divider = cols.map(c => '─'.repeat(widths[c] || 12)).join('┼');
   return `  ┌${'─'.repeat(divider.length)}┐\n  │${header}│\n  ├${divider}┤`;
 }
 
 function renderFieldRow(row, cols, widths, isActive, activeCol) {
   const cells = cols.map((col, ci) => {
-    let val = row[col] ?? '';
-    if (col === 'pk' || col === 'fk') val = val ? chalk.green('◼') : chalk.dim('◻');
+    const colW       = widths[col] || 12;
     const isThisCell = isActive && ci === activeCol;
-    const cell = pad(val, widths[col] || 12);
-    return isThisCell ? chalk.bgBlue.white(cell) : (isActive ? chalk.white(cell) : chalk.dim(cell));
+
+    let cell;
+    if (BOOL_COLS.has(col)) {
+      // Boolean: pad the plain glyph first so width is exact, then colorize
+      const glyph = pad(row[col] ? '◼' : '◻', colW);
+      cell = isThisCell
+        ? chalk.bgBlue.white(glyph)
+        : (row[col] ? chalk.green(glyph) : chalk.dim(glyph));
+    } else {
+      // Text / cycle: pad plain text, then colorize — ANSI codes added after padding
+      const plain = pad(String(row[col] ?? ''), colW);
+      cell = isThisCell
+        ? chalk.bgBlue.white(plain)
+        : (isActive ? chalk.white(plain) : chalk.dim(plain));
+    }
+
+    return cell;
   }).join(chalk.dim('│'));
   return `  │${cells}│`;
 }
 
 /**
- * Interactive fields table
- * Returns array of field objects
+ * Count of lines the table currently occupies (for accurate clearLines).
+ *   1  blank line before title
+ *   1  title line
+ *   3  header block (top border + header row + divider)
+ *   N  data rows
+ *   1  bottom border
+ *   1  hint line
+ *   +  type menu lines (when open)
+ */
+function tableLineCount(rowCount, typeMenuOpen) {
+  return 1 + 1 + 3 + rowCount + 1 + 1 + (typeMenuOpen ? FIELD_TYPES.length + 2 : 0);
+}
+
+function cycleValue(col, current) {
+  const opts = CYCLE_COLS[col];
+  if (!opts) return current;
+  return opts[(opts.indexOf(current) + 1) % opts.length];
+}
+
+/**
+ * Interactive fields table.
+ * Returns array of field objects.
  */
 export async function fieldsTable(initialRows, cols, widths, title) {
   const rows = initialRows.map(r => ({ ...r }));
   let rowIdx = 0;
   let colIdx = 0;
-  let editBuffer = null; // currently editing text cell
   let typeMenuOpen = false;
-  let typeMenuIdx = 0;
-
-  const toggleCols = cols.filter(c => c === 'pk' || c === 'fk');
-  const textCols   = cols.filter(c => c !== 'pk' && c !== 'fk');
-
-  function totalLines() {
-    return rows.length + 4; // header(3) + footer(1)
-  }
+  let typeMenuIdx  = 0;
 
   function render(initial = false) {
-    if (!initial) clearLines(totalLines() + (typeMenuOpen ? FIELD_TYPES.length + 2 : 0));
+    if (!initial) clearLines(tableLineCount(rows.length, typeMenuOpen));
 
     console.log('\n  ' + chalk.bold.white(title));
     console.log(renderTableHeader(cols, widths));
-
     rows.forEach((row, ri) => {
       console.log(renderFieldRow(row, cols, widths, ri === rowIdx, colIdx));
     });
-
-    console.log(`  └${'─'.repeat(cols.map(c => widths[c] || 12).reduce((a, b) => a + b, 0) + cols.length - 1)}┘`);
-    console.log(chalk.dim('  ← → cols   ↑ ↓ rows   + add row   - del row   space toggle pk/fk   enter done'));
+    const totalW = cols.map(c => widths[c] || 12).reduce((a, b) => a + b + 1, -1);
+    console.log(`  └${'─'.repeat(totalW)}┘`);
+    console.log(chalk.dim('  ← → cols   ↑ ↓ rows   + add   - del   space toggle/cycle   enter done'));
 
     if (typeMenuOpen) {
       console.log('');
@@ -240,30 +271,29 @@ export async function fieldsTable(initialRows, cols, widths, title) {
     const onKey = (key) => {
       if (key === KEYS.CTRL_C) { showCursor(); disableRawInput(); process.exit(0); }
 
-      // Type menu open
+      // ── Type picker ─────────────────────────────────────────────────────────
       if (typeMenuOpen) {
         if (key === KEYS.UP)    { typeMenuIdx = (typeMenuIdx - 1 + FIELD_TYPES.length) % FIELD_TYPES.length; render(); return; }
         if (key === KEYS.DOWN)  { typeMenuIdx = (typeMenuIdx + 1) % FIELD_TYPES.length; render(); return; }
-        if (key === KEYS.ENTER) {
-          rows[rowIdx].type = FIELD_TYPES[typeMenuIdx];
-          typeMenuOpen = false;
-          render();
-          return;
-        }
-        if (key === KEYS.ESC) { typeMenuOpen = false; render(); return; }
+        if (key === KEYS.ENTER) { rows[rowIdx].type = FIELD_TYPES[typeMenuIdx]; typeMenuOpen = false; render(); return; }
+        if (key === KEYS.ESC)   { typeMenuOpen = false; render(); return; }
         return;
       }
 
-      // Navigation
-      if (key === KEYS.UP)    { rowIdx = Math.max(0, rowIdx - 1); editBuffer = null; render(); return; }
-      if (key === KEYS.DOWN)  { rowIdx = Math.min(rows.length - 1, rowIdx + 1); editBuffer = null; render(); return; }
-      if (key === KEYS.LEFT)  { colIdx = Math.max(0, colIdx - 1); editBuffer = null; render(); return; }
-      if (key === KEYS.RIGHT) { colIdx = Math.min(cols.length - 1, colIdx + 1); editBuffer = null; render(); return; }
+      // ── Navigation ──────────────────────────────────────────────────────────
+      if (key === KEYS.UP)    { rowIdx = Math.max(0, rowIdx - 1); render(); return; }
+      if (key === KEYS.DOWN)  { rowIdx = Math.min(rows.length - 1, rowIdx + 1); render(); return; }
+      if (key === KEYS.LEFT)  { colIdx = Math.max(0, colIdx - 1); render(); return; }
+      if (key === KEYS.RIGHT) { colIdx = Math.min(cols.length - 1, colIdx + 1); render(); return; }
 
-      // Add / remove rows
+      // ── Add / remove rows ───────────────────────────────────────────────────
       if (key === KEYS.PLUS) {
         const newRow = {};
-        cols.forEach(c => { newRow[c] = c === 'pk' || c === 'fk' ? false : ''; });
+        cols.forEach(c => {
+          if (BOOL_COLS.has(c))       newRow[c] = false;
+          else if (CYCLE_COLS[c])     newRow[c] = CYCLE_COLS[c][0];
+          else                        newRow[c] = '';
+        });
         rows.splice(rowIdx + 1, 0, newRow);
         rowIdx++;
         render();
@@ -275,29 +305,35 @@ export async function fieldsTable(initialRows, cols, widths, title) {
         return;
       }
 
-      // Toggle pk/fk
+      // ── Space ───────────────────────────────────────────────────────────────
       if (key === KEYS.SPACE) {
         const col = cols[colIdx];
-        if (col === 'pk' || col === 'fk') {
+
+        if (BOOL_COLS.has(col)) {
           rows[rowIdx][col] = !rows[rowIdx][col];
-          // Only one PK allowed
+          // Enforce single PK
           if (col === 'pk' && rows[rowIdx][col]) {
             rows.forEach((r, i) => { if (i !== rowIdx) r.pk = false; });
           }
           render();
           return;
         }
-        // Open type menu on type column
+
+        if (CYCLE_COLS[col]) {
+          rows[rowIdx][col] = cycleValue(col, rows[rowIdx][col]);
+          render();
+          return;
+        }
+
         if (col === 'type') {
           typeMenuOpen = true;
-          typeMenuIdx = FIELD_TYPES.indexOf(rows[rowIdx].type || 'varchar');
-          if (typeMenuIdx < 0) typeMenuIdx = 0;
+          typeMenuIdx  = Math.max(0, FIELD_TYPES.indexOf(rows[rowIdx].type || 'varchar'));
           render();
           return;
         }
       }
 
-      // Done
+      // ── Enter ────────────────────────────────────────────────────────────────
       if (key === KEYS.ENTER) {
         const col = cols[colIdx];
         if (col === 'type') { typeMenuOpen = true; typeMenuIdx = 0; render(); return; }
@@ -308,9 +344,9 @@ export async function fieldsTable(initialRows, cols, widths, title) {
         return;
       }
 
-      // Text editing for current cell
+      // ── Text editing ─────────────────────────────────────────────────────────
       const col = cols[colIdx];
-      if (col === 'pk' || col === 'fk') return;
+      if (BOOL_COLS.has(col) || CYCLE_COLS[col]) return;   // not typed
 
       if (key === KEYS.BACKSPACE) {
         rows[rowIdx][col] = String(rows[rowIdx][col] || '').slice(0, -1);
@@ -318,7 +354,6 @@ export async function fieldsTable(initialRows, cols, widths, title) {
         return;
       }
 
-      // Printable character
       if (key.length === 1 && key >= ' ') {
         rows[rowIdx][col] = (rows[rowIdx][col] || '') + key;
         render();