@tn3270/gui 0.0.0-stage → 0.1.0

package/app/transferBoot.js

@@ -0,0 +1,531 @@
+// packages/frontend/dist/transferForm.js
+var TRANSFER_FIELDS = [
+  { id: "direction", label: "Direction", kind: "cycle", values: ["receive", "send"], width: 0 },
+  { id: "host", label: "Host", kind: "cycle", values: ["tso", "vm"], width: 0 },
+  { id: "localFile", label: "Local file", kind: "text", values: [], width: 40 },
+  { id: "hostFile", label: "Host file", kind: "text", values: [], width: 40 },
+  { id: "mode", label: "Mode", kind: "cycle", values: ["binary", "ascii"], width: 0 },
+  { id: "exist", label: "Exist", kind: "cycle", values: ["keep", "replace", "append"], width: 0 },
+  { id: "cr", label: "Cr", kind: "cycle", values: ["", "auto", "remove", "add", "keep"], width: 0 },
+  { id: "recfm", label: "Recfm", kind: "cycle", values: ["", "fixed", "variable", "undefined"], width: 0 },
+  { id: "lrecl", label: "Lrecl", kind: "numeric", values: [], width: 5 },
+  { id: "blksize", label: "Blksize", kind: "numeric", values: [], width: 5 }
+];
+function directionLabel(value) {
+  if (value === "send")
+    return "send: local to host";
+  if (value === "receive")
+    return "receive: host to local";
+  return value;
+}
+var FIELD_BY_ID = new Map(TRANSFER_FIELDS.map((f) => [f.id, f]));
+function newTransferForm() {
+  return {
+    values: {
+      direction: "send",
+      host: "tso",
+      localFile: "",
+      hostFile: "",
+      mode: "binary",
+      exist: "keep",
+      cr: "",
+      recfm: "",
+      lrecl: "",
+      blksize: ""
+    },
+    selected: 0
+  };
+}
+function valuesFor(id, values) {
+  const field = FIELD_BY_ID.get(id);
+  if (field === void 0)
+    return [];
+  if (id === "recfm" && values.host === "vm") {
+    return field.values.filter((v) => v !== "undefined");
+  }
+  return field.values;
+}
+function cycleField(state, id, delta) {
+  const field = FIELD_BY_ID.get(id);
+  if (field === void 0 || field.kind !== "cycle")
+    return state;
+  const options = valuesFor(id, state.values);
+  const at = options.indexOf(state.values[id]);
+  const next = options[((at + delta) % options.length + options.length) % options.length];
+  return clearInapplicable({
+    ...state,
+    values: { ...state.values, [id]: next ?? "" },
+    error: void 0
+  });
+}
+function setFieldText(state, id, text) {
+  const field = FIELD_BY_ID.get(id);
+  if (field === void 0 || field.kind === "cycle")
+    return state;
+  if (field.kind === "numeric" && !/^[0-9]*$/.test(text))
+    return state;
+  if (text.length > field.width && field.kind === "numeric")
+    return state;
+  return { ...state, values: { ...state.values, [id]: text }, error: void 0 };
+}
+function applicable(id, values) {
+  switch (id) {
+    // On a receive the dataset already exists, and x3270 silently drops these
+    // (`ft.c:702`). Silently dropping is exactly what a form should make visible.
+    case "recfm":
+      return values.direction === "send";
+    // `Lrecl=80` with no `Recfm` "emits nothing at all" (`ft.c:704,721-726`), so the
+    // field would be a lie while Recfm is unset.
+    case "lrecl":
+      return values.direction === "send" && values.recfm !== "";
+    // CMS files have no block size.
+    case "blksize":
+      return values.direction === "send" && values.recfm !== "" && values.host !== "vm";
+    // Carriage-return translation is meaningless on a binary transfer.
+    case "cr":
+      return values.mode === "ascii";
+    default:
+      return true;
+  }
+}
+function clearInapplicable(state) {
+  const values = { ...state.values };
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const f of TRANSFER_FIELDS) {
+      if (!applicable(f.id, values) && values[f.id] !== "") {
+        values[f.id] = "";
+        changed = true;
+      }
+    }
+    if (values.host === "vm" && values.recfm === "undefined") {
+      values.recfm = "";
+      changed = true;
+    }
+  }
+  return { ...state, values };
+}
+function formKeywords(state) {
+  const out = [];
+  const keyword = {
+    direction: "Direction",
+    host: "Host",
+    localFile: "LocalFile",
+    hostFile: "HostFile",
+    mode: "Mode",
+    exist: "Exist",
+    cr: "Cr",
+    recfm: "Recfm",
+    lrecl: "Lrecl",
+    blksize: "Blksize"
+  };
+  for (const f of TRANSFER_FIELDS) {
+    const value = state.values[f.id];
+    if (value === "" || !applicable(f.id, state.values))
+      continue;
+    out.push(`${keyword[f.id]}=${value}`);
+  }
+  return out;
+}
+
+// packages/canvas/dist/transferUi.js
+function caretAfterEdit(remembered, typed, shown) {
+  const clamp = (n) => Math.max(0, Math.min(n, shown.length));
+  if (remembered.start === null)
+    return { start: shown.length, end: shown.length };
+  const dropped = typed.length - shown.length;
+  const start = clamp(remembered.start - dropped);
+  const end = clamp((remembered.end ?? remembered.start) - dropped);
+  return { start, end: Math.max(start, end) };
+}
+var HELP = "Choose a local file and name the host file, then Start.";
+function createTransferUi(deps) {
+  let state = newTransferForm();
+  let isRunning = false;
+  const view = () => {
+    const out = [];
+    for (const f of TRANSFER_FIELDS) {
+      if (!applicable(f.id, state.values))
+        continue;
+      const options = f.kind === "cycle" ? offered(f.id) : [];
+      out.push({
+        id: f.id,
+        label: f.label,
+        kind: f.kind,
+        value: state.values[f.id],
+        options,
+        // ONE MAPPING FOR EVERY CYCLE FIELD rather than a special case for `direction`:
+        // `directionLabel` returns anything it does not recognise unchanged, so this is the
+        // identity for the rest. Built HERE rather than in each renderer because both `<select>`
+        // builders would otherwise carry the same decision, which is how two front ends drift.
+        optionLabels: options.map((o) => f.id === "direction" ? directionLabel(o) : o)
+      });
+    }
+    return out;
+  };
+  const offered = (id) => {
+    const field = TRANSFER_FIELDS.find((f) => f.id === id);
+    if (field === void 0)
+      return [];
+    const seen = [];
+    let probe = state;
+    for (let i = 0; i < field.values.length + 1; i++) {
+      const v = probe.values[id];
+      if (seen.includes(v))
+        break;
+      seen.push(v);
+      probe = cycleField(probe, id, 1);
+    }
+    return field.values.filter((v) => seen.includes(v));
+  };
+  const redraw = () => {
+    deps.render(view());
+  };
+  const show = () => {
+    if (state.error !== void 0) {
+      deps.setStatus(state.error);
+      return;
+    }
+    deps.setStatus(HELP);
+  };
+  redraw();
+  show();
+  return {
+    values: () => state.values,
+    running: () => isRunning,
+    cycle(id, delta) {
+      if (isRunning)
+        return;
+      state = cycleField(state, id, delta);
+      redraw();
+      show();
+    },
+    type(id, text) {
+      if (isRunning)
+        return;
+      state = setFieldText(state, id, text);
+      redraw();
+      show();
+    },
+    async browseLocal() {
+      if (isRunning)
+        return;
+      const chosen = await deps.browse(state.values.direction);
+      if (isRunning)
+        return;
+      if (chosen === void 0)
+        return;
+      state = setFieldText(state, "localFile", chosen);
+      redraw();
+      show();
+    },
+    /**
+     * Submit the form, ANNOUNCING THE TRANSFER BEFORE THE AWAIT RATHER THAN AFTER IT.
+     *
+     * ## THE INVARIANT: AN ENDING THAT HAS ALREADY ARRIVED MUST NOT BE UNDONE BY THE SUBMIT THAT
+     * ## STARTED IT
+     *
+     * This method used to `await deps.submit(...)` and only THEN arm `isRunning` and paint
+     * `transferring`. That is the renderer's copy of the bug `transferWindow.ts`'s `startRun`
+     * documents at length, and it is REACHABLE for the same reason: `startTransfer` can call
+     * `onDone` BEFORE IT RETURNS -- a whole DFT transfer finishing inside
+     * `session.sendAID(AID.ENTER)`'s record handling, `transferRun.ts:377`'s
+     * `if (ended) return { ok: true };`, driven against a real `Session` by
+     * `tui/test/transferRun.test.ts`'s "notices a DFT transfer that finished BEFORE the first
+     * wait". The controller's `finish` then runs INSIDE the `ipcMain.handle` handler and issues
+     * `webContents.send('transfer:done', ...)`, and that send reaches the renderer BEFORE the
+     * `invoke()` promise resolves -- measured in real Electron 44, 20 runs out of 20.
+     *
+     * So `finished()` ran first and this method's tail then clobbered it: a transfer that had
+     * SUCCEEDED reported as permanently in progress, `Cancel` was dead (this object's
+     * `requestCancel` passed its own `isRunning` check and main's answered
+     * `if (run === undefined) return;`), and `Start` was dead for the window's life. Measured
+     * against the built module: `setRunning false` / `setStatus "done: 3 bytes"` /
+     * `setRunning true` / `setStatus "transferring"`, leaving `running() === true`.
+     *
+     * ## THE FIX IS THE SHAPE THIS MODULE'S OTHER HALF ALREADY USES, WITH NO NEW STATE
+     *
+     * `isRunning` is armed, and the whole "we are transferring" announcement made, BEFORE the
+     * await. The tail is then EMPTY on the success path -- there is nothing left to clobber with
+     * -- and `isRunning` doubles as the latch: `finished()` clears it, so the refusal arm below is
+     * CONDITIONAL on this submit still being the one the form is waiting for. That is exactly
+     * `startRun`'s placeholder-then-conditional-assignment, and it adds no second word for "is a
+     * transfer running"; a renderer-side generation counter would have been one more fact to keep
+     * in step with main's, and nothing here could falsify it.
+     *
+     * TWO SIBLING HAZARDS CLOSE WITH IT, both from the same await:
+     *
+     *  - A `transfer:progress` arriving during the await used to be DROPPED by `progress()`'s
+     *    `if (!isRunning) return;`, and then painted over by the tail's `transferring` even if it
+     *    had not been. Both ends are fixed: the flag is already armed when it arrives, and the
+     *    tail no longer paints.
+     *  - A SECOND Start during the await used to pass the guard below -- two `invoke`s for one
+     *    button -- and came back as main's 'a transfer is already running', a message about the
+     *    operator's OWN transfer. The early arming refuses the second press here instead.
+     */
+    async start() {
+      if (isRunning)
+        return;
+      isRunning = true;
+      state = { ...state, error: void 0 };
+      deps.setRunning(true);
+      deps.setStatus("transferring");
+      let refusal;
+      try {
+        const result = await deps.submit(formKeywords(state));
+        if (!result.ok)
+          refusal = result.error ?? "transfer refused";
+      } catch (err) {
+        refusal = `transfer refused: ${err instanceof Error ? err.message : String(err)}`;
+      }
+      if (!isRunning)
+        return;
+      if (refusal === void 0)
+        return;
+      isRunning = false;
+      deps.setRunning(false);
+      state = { ...state, error: refusal };
+      show();
+    },
+    requestCancel() {
+      if (!isRunning)
+        return;
+      deps.cancel();
+    },
+    progress(text) {
+      if (!isRunning)
+        return;
+      deps.setStatus(text);
+    },
+    finished(result) {
+      isRunning = false;
+      deps.setRunning(false);
+      if (result.ok) {
+        deps.setStatus(`done: ${result.bytes ?? 0} bytes`);
+        return;
+      }
+      deps.setStatus(result.error ?? "transfer failed");
+    }
+  };
+}
+
+// packages/gui/dist/transferBoot.js
+var bridge = window.tn3270transfer;
+var fields = document.querySelector("#fields");
+var status = document.querySelector("#status");
+var startBtn = document.querySelector("#start");
+var cancelBtn = document.querySelector("#cancel");
+if (fields === null || status === null || startBtn === null || cancelBtn === null) {
+  throw new Error("transfer.html is missing one of #fields, #status, #start, #cancel");
+}
+var running = false;
+var rememberFocus = () => {
+  const active = document.activeElement;
+  const tagged = active instanceof HTMLInputElement || active instanceof HTMLSelectElement || active instanceof HTMLButtonElement;
+  if (!tagged)
+    return void 0;
+  const field = active.dataset["field"];
+  if (field === void 0)
+    return void 0;
+  const role = active.dataset["role"] === "browse" ? "browse" : "value";
+  if (active instanceof HTMLInputElement) {
+    return {
+      field,
+      role,
+      start: active.selectionStart,
+      end: active.selectionEnd,
+      typed: active.value
+    };
+  }
+  return { field, role, start: null, end: null, typed: "" };
+};
+var restoreFocus = (memo) => {
+  if (memo === void 0)
+    return;
+  const el = fields.querySelector(`[data-field="${memo.field}"][data-role="${memo.role}"]`);
+  if (el instanceof HTMLButtonElement) {
+    el.focus();
+    return;
+  }
+  if (!(el instanceof HTMLInputElement) && !(el instanceof HTMLSelectElement))
+    return;
+  el.focus();
+  if (!(el instanceof HTMLInputElement))
+    return;
+  const { start, end } = caretAfterEdit(memo, memo.typed, el.value);
+  el.setSelectionRange(start, end);
+};
+var ui = createTransferUi({
+  render(list) {
+    const memo = rememberFocus();
+    fields.replaceChildren();
+    for (const f of list) {
+      const row = document.createElement("div");
+      row.className = "row";
+      const label = document.createElement("label");
+      label.textContent = f.label;
+      row.append(label);
+      if (f.kind === "cycle") {
+        const select = document.createElement("select");
+        select.dataset["field"] = f.id;
+        select.dataset["role"] = "value";
+        for (const [i, opt] of f.options.entries()) {
+          const o = document.createElement("option");
+          o.value = opt;
+          o.textContent = opt === "" ? "(host default)" : f.optionLabels[i] ?? opt;
+          if (opt === f.value)
+            o.selected = true;
+          select.append(o);
+        }
+        select.disabled = running;
+        select.addEventListener("change", () => {
+          const from = f.options.indexOf(f.value);
+          const to = f.options.indexOf(select.value);
+          if (from >= 0 && to >= 0 && to !== from)
+            ui.cycle(f.id, to - from);
+        });
+        row.append(select);
+      } else {
+        const input = document.createElement("input");
+        input.type = "text";
+        input.dataset["field"] = f.id;
+        input.dataset["role"] = "value";
+        input.value = f.value;
+        input.disabled = running;
+        input.addEventListener("input", () => {
+          ui.type(f.id, input.value);
+        });
+        row.append(input);
+      }
+      if (f.id === "localFile") {
+        const browse = document.createElement("button");
+        browse.textContent = "Browse\u2026";
+        browse.dataset["field"] = f.id;
+        browse.dataset["role"] = "browse";
+        browse.disabled = running;
+        browse.addEventListener("click", () => {
+          void ui.browseLocal();
+        });
+        row.append(browse);
+      } else {
+        row.append(document.createElement("span"));
+      }
+      fields.append(row);
+    }
+    restoreFocus(memo);
+  },
+  setStatus(text) {
+    status.textContent = text;
+  },
+  /**
+   * Push the running state to the DOM, and to the flag `render` reads.
+   *
+   * ## WHY `render` STILL CONSULTS `running` -- DEFENSE IN DEPTH, NOT THE PRIMARY GUARD
+   *
+   * The interleaving this covers is `browseLocal`'s: it checks `isRunning` before its `await
+   * deps.browse(...)` and redraws after, so a dialog that is not modal to this window lets the
+   * operator press Start while it is open and a late resolution rebuild every control mid-transfer.
+   * Measured in real Electron with a deferred `browse`.
+   *
+   * THE PRIMARY FIX IS IN `transferUi.ts`: a second `isRunning` check immediately after that await,
+   * which also stops the two worse halves of the same bug (a redraw's `show()` clobbering the live
+   * progress line, and `setFieldText` mutating the model mid-transfer). With that in place, this
+   * assignment is arguably unreachable -- almost every render happens while idle, since `cycle` and
+   * `type` return early when running and `start`/`progress`/`finished` never redraw.
+   *
+   * KEPT ANYWAY, DELIBERATELY. It is the enablement third of the hazard, and a pair like this is
+   * invisible to single mutation: removing either half leaves the other half's tests green, which
+   * this repo has now recorded twice. So neither half should be deleted on the evidence of a green
+   * suite. The same note is on the post-await check in `transferUi.ts`, at the other end of the
+   * pair, because whoever deletes one will be reading only that end.
+   */
+  setRunning(isRunning) {
+    running = isRunning;
+    startBtn.disabled = isRunning;
+    cancelBtn.disabled = !isRunning;
+    for (const el of fields.querySelectorAll("input, select, button")) {
+      el.disabled = isRunning;
+    }
+  },
+  browse: (direction) => bridge.browse(direction),
+  submit: (keywords) => bridge.submit(keywords),
+  cancel: () => {
+    bridge.cancel();
+  }
+});
+startBtn.addEventListener("click", () => {
+  void ui.start();
+});
+cancelBtn.addEventListener("click", () => {
+  ui.requestCancel();
+});
+bridge.onProgress((text) => {
+  ui.progress(text);
+});
+bridge.onDone((r) => {
+  ui.finished(r);
+});
+window.__tn3270SetField = (id, text) => {
+  ui.type(id, text);
+  return ui.values()[id] ?? "";
+};
+window.__tn3270FieldKind = (id) => {
+  const el = fields.querySelector(`[data-field="${id}"][data-role="value"]`);
+  if (el instanceof HTMLSelectElement)
+    return "cycle";
+  if (el instanceof HTMLInputElement)
+    return "text";
+  return "";
+};
+window.__tn3270CycleField = (id, to) => {
+  const field = id;
+  for (let i = 0; i < 12; i++) {
+    if (ui.values()[field] === to)
+      break;
+    ui.cycle(field, 1);
+  }
+  return ui.values()[field] ?? "";
+};
+window.__tn3270Submit = async () => {
+  await ui.start();
+  const status2 = document.querySelector("#status")?.textContent ?? "";
+  return { ok: ui.running(), status: status2 };
+};
+window.__tn3270AwaitDone = async (budgetMs) => {
+  const deadline = Date.now() + budgetMs;
+  while (ui.running() && Date.now() < deadline) {
+    await new Promise((r) => {
+      setTimeout(r, 250);
+    });
+  }
+  return {
+    running: ui.running(),
+    status: document.querySelector("#status")?.textContent ?? "",
+    timedOut: ui.running()
+  };
+};
+window.__tn3270SampleStatus = async (budgetMs, everyMs) => {
+  const seen = [];
+  const deadline = Date.now() + budgetMs;
+  for (; ; ) {
+    const text = document.querySelector("#status")?.textContent ?? "";
+    if (seen[seen.length - 1] !== text)
+      seen.push(text);
+    if (!ui.running() || Date.now() >= deadline)
+      return seen;
+    await new Promise((r) => {
+      setTimeout(r, everyMs);
+    });
+  }
+};
+window.__tn3270ClickCancel = () => {
+  const btn = document.querySelector("#cancel");
+  const statusBefore = document.querySelector("#status")?.textContent ?? "";
+  if (btn === null)
+    return { enabled: false, statusBefore };
+  const enabled = !btn.disabled;
+  btn.click();
+  return { enabled, statusBefore };
+};
+//# sourceMappingURL=transferBoot.js.map