@suds-cli/textinput 0.0.1-alpha.0 → 0.1.0-alpha.1

package/dist/index.cjs

@@ -0,0 +1,665 @@
+'use strict';
+
+var chapstick = require('@suds-cli/chapstick');
+var cursor = require('@suds-cli/cursor');
+var key = require('@suds-cli/key');
+var tea = require('@suds-cli/tea');
+var runeutil = require('@suds-cli/runeutil');
+var GraphemeSplitter = require('grapheme-splitter');
+var clipboard = require('clipboardy');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var GraphemeSplitter__default = /*#__PURE__*/_interopDefault(GraphemeSplitter);
+var clipboard__default = /*#__PURE__*/_interopDefault(clipboard);
+
+// src/model.ts
+var PasteMsg = class {
+  constructor(text) {
+    this.text = text;
+  }
+  _tag = "textinput/paste";
+};
+var PasteErrorMsg = class {
+  constructor(error) {
+    this.error = error;
+  }
+  _tag = "textinput/paste-error";
+};
+function pasteCommand() {
+  return async () => {
+    try {
+      const text = await clipboard__default.default.read();
+      return new PasteMsg(text ?? "");
+    } catch (error) {
+      return new PasteErrorMsg(error);
+    }
+  };
+}
+var EchoMode = /* @__PURE__ */ ((EchoMode2) => {
+  EchoMode2["Normal"] = "normal";
+  EchoMode2["Password"] = "password";
+  EchoMode2["None"] = "none";
+  return EchoMode2;
+})(EchoMode || {});
+var defaultKeyMap = {
+  characterForward: key.newBinding({ keys: ["right", "ctrl+f"] }),
+  characterBackward: key.newBinding({ keys: ["left", "ctrl+b"] }),
+  wordForward: key.newBinding({ keys: ["alt+right", "ctrl+right", "alt+f"] }),
+  wordBackward: key.newBinding({ keys: ["alt+left", "ctrl+left", "alt+b"] }),
+  deleteWordBackward: key.newBinding({ keys: ["alt+backspace", "ctrl+w"] }),
+  deleteWordForward: key.newBinding({ keys: ["alt+delete", "alt+d"] }),
+  deleteAfterCursor: key.newBinding({ keys: ["ctrl+k"] }),
+  deleteBeforeCursor: key.newBinding({ keys: ["ctrl+u"] }),
+  deleteCharacterBackward: key.newBinding({ keys: ["backspace", "ctrl+h"] }),
+  deleteCharacterForward: key.newBinding({ keys: ["delete", "ctrl+d"] }),
+  lineStart: key.newBinding({ keys: ["home", "ctrl+a"] }),
+  lineEnd: key.newBinding({ keys: ["end", "ctrl+e"] }),
+  paste: key.newBinding({ keys: ["ctrl+v"] })
+};
+
+// src/model.ts
+var splitter = new GraphemeSplitter__default.default();
+var sanitizer = runeutil.newSanitizer({ replaceNewLine: " ", replaceTab: " " });
+var TextInputModel = class _TextInputModel {
+  value;
+  position;
+  focused;
+  placeholder;
+  echoMode;
+  echoCharacter;
+  charLimit;
+  width;
+  prompt;
+  promptStyle;
+  textStyle;
+  placeholderStyle;
+  cursorStyle;
+  validateFn;
+  keyMap;
+  cursor;
+  error;
+  constructor(state) {
+    this.value = state.value;
+    this.position = state.position;
+    this.focused = state.focused;
+    this.placeholder = state.placeholder;
+    this.echoMode = state.echoMode;
+    this.echoCharacter = state.echoCharacter;
+    this.charLimit = state.charLimit;
+    this.width = state.width;
+    this.prompt = state.prompt;
+    this.promptStyle = state.promptStyle;
+    this.textStyle = state.textStyle;
+    this.placeholderStyle = state.placeholderStyle;
+    this.cursorStyle = state.cursorStyle;
+    this.validateFn = state.validateFn;
+    this.keyMap = state.keyMap;
+    this.cursor = state.cursor;
+    this.error = state.error;
+  }
+  /** Create a new text input model. */
+  static new(options = {}) {
+    const sanitized = clampToLimit(
+      sanitizeValue(options.value ?? ""),
+      options.charLimit ?? 0
+    );
+    const baseTextStyle = options.textStyle ?? new chapstick.Style();
+    const cursorMode = options.cursorMode ?? cursor.CursorMode.Blink;
+    const cursor$1 = new cursor.CursorModel({
+      style: options.cursorStyle ?? new chapstick.Style(),
+      textStyle: baseTextStyle,
+      mode: cursorMode,
+      focused: false,
+      char: " "
+    });
+    const model = new _TextInputModel({
+      value: sanitized,
+      position: runeCount(sanitized),
+      focused: false,
+      placeholder: options.placeholder ?? "",
+      echoMode: options.echoMode ?? "normal" /* Normal */,
+      echoCharacter: options.echoCharacter ?? "\u2022",
+      charLimit: options.charLimit ?? 0,
+      width: options.width ?? 0,
+      prompt: options.prompt ?? "> ",
+      promptStyle: options.promptStyle ?? new chapstick.Style(),
+      textStyle: baseTextStyle,
+      placeholderStyle: options.placeholderStyle ?? new chapstick.Style(),
+      cursorStyle: options.cursorStyle ?? new chapstick.Style(),
+      validateFn: options.validate,
+      keyMap: options.keyMap ?? defaultKeyMap,
+      cursor: cursor$1,
+      error: null
+    });
+    return model.#withError(model.#runValidation(sanitized));
+  }
+  /** Initial command (none needed by default). */
+  init() {
+    return null;
+  }
+  /** Current value. */
+  valueOf() {
+    return this.value;
+  }
+  /** Length in graphemes. */
+  length() {
+    return runeCount(this.value);
+  }
+  /** True if no content. */
+  isEmpty() {
+    return this.length() === 0;
+  }
+  /** Cursor position in graphemes. */
+  cursorPosition() {
+    return this.position;
+  }
+  /** Focus the input (shows cursor, enables key handling). */
+  focus() {
+    if (this.focused) {
+      return [this, null];
+    }
+    const [cursor, cmd] = this.cursor.focus();
+    const next = this.#with({ focused: true, cursor });
+    return [next, cmd];
+  }
+  /** Blur the input (hides cursor, ignores key handling). */
+  blur() {
+    if (!this.focused) {
+      return this;
+    }
+    return this.#with({ focused: false, cursor: this.cursor.blur() });
+  }
+  /** Move cursor to start. */
+  cursorStart() {
+    return this.#withPosition(0);
+  }
+  /** Move cursor to end. */
+  cursorEnd() {
+    return this.#withPosition(this.length());
+  }
+  /** Move cursor left by n (default 1). */
+  cursorLeft(n = 1) {
+    return this.#withPosition(Math.max(0, this.position - Math.max(1, n)));
+  }
+  /** Move cursor right by n (default 1). */
+  cursorRight(n = 1) {
+    return this.#withPosition(
+      Math.min(this.length(), this.position + Math.max(1, n))
+    );
+  }
+  /** Move cursor one word to the left. */
+  wordLeft() {
+    if (this.position === 0 || this.isEmpty()) {
+      return this;
+    }
+    if (this.echoMode !== "normal" /* Normal */) {
+      return this.cursorStart();
+    }
+    const graphemes = splitGraphemes(this.value);
+    let i = this.position - 1;
+    while (i >= 0) {
+      const g = graphemes[i];
+      if (g && isWhitespace(g)) {
+        i--;
+        continue;
+      }
+      break;
+    }
+    while (i >= 0) {
+      const g = graphemes[i];
+      if (g && !isWhitespace(g)) {
+        i--;
+        continue;
+      }
+      break;
+    }
+    return this.#withPosition(Math.max(0, i + 1));
+  }
+  /** Move cursor one word to the right. */
+  wordRight() {
+    if (this.position >= this.length() || this.isEmpty()) {
+      return this;
+    }
+    if (this.echoMode !== "normal" /* Normal */) {
+      return this.cursorEnd();
+    }
+    const graphemes = splitGraphemes(this.value);
+    let i = this.position;
+    while (i < graphemes.length) {
+      const g = graphemes[i];
+      if (g && isWhitespace(g)) {
+        i++;
+        continue;
+      }
+      break;
+    }
+    while (i < graphemes.length) {
+      const g = graphemes[i];
+      if (g && !isWhitespace(g)) {
+        i++;
+        continue;
+      }
+      break;
+    }
+    return this.#withPosition(Math.min(this.length(), i));
+  }
+  /** Insert runes at the cursor position. */
+  insertRunes(runes) {
+    if (!runes) {
+      return this;
+    }
+    const sanitized = sanitizeValue(runes);
+    if (!sanitized) {
+      return this;
+    }
+    const before = sliceGraphemes(this.value, 0, this.position);
+    const after = sliceGraphemes(this.value, this.position);
+    const insertion = clampGraphemes(
+      sanitized,
+      this.#remainingCapacity(before + after)
+    );
+    const nextValue = before + insertion + after;
+    const nextPos = this.position + runeCount(insertion);
+    return this.#withValue(nextValue, nextPos);
+  }
+  /** Delete up to n runes to the left of the cursor. */
+  deleteLeft(n = 1) {
+    if (this.position === 0 || n <= 0) {
+      return this;
+    }
+    const remove = Math.min(n, this.position);
+    const before = sliceGraphemes(this.value, 0, this.position - remove);
+    const after = sliceGraphemes(this.value, this.position);
+    return this.#withValue(before + after, this.position - remove);
+  }
+  /** Delete up to n runes to the right of the cursor. */
+  deleteRight(n = 1) {
+    if (this.position >= this.length() || n <= 0) {
+      return this;
+    }
+    const before = sliceGraphemes(this.value, 0, this.position);
+    const after = sliceGraphemes(this.value, this.position + Math.max(1, n));
+    return this.#withValue(before + after, this.position);
+  }
+  /** Delete the word to the left of the cursor. */
+  deleteWordLeft() {
+    if (this.position === 0 || this.isEmpty()) {
+      return this;
+    }
+    if (this.echoMode !== "normal" /* Normal */) {
+      return this.deleteToStart();
+    }
+    const graphemes = splitGraphemes(this.value);
+    let start = this.position;
+    while (start > 0) {
+      const g = graphemes[start - 1];
+      if (g && isWhitespace(g)) {
+        start--;
+        continue;
+      }
+      break;
+    }
+    while (start > 0) {
+      const g = graphemes[start - 1];
+      if (g && !isWhitespace(g)) {
+        start--;
+        continue;
+      }
+      break;
+    }
+    const before = graphemes.slice(0, start).join("");
+    const after = graphemes.slice(this.position).join("");
+    return this.#withValue(before + after, start);
+  }
+  /** Delete the word to the right of the cursor. */
+  deleteWordRight() {
+    if (this.position >= this.length() || this.isEmpty()) {
+      return this;
+    }
+    if (this.echoMode !== "normal" /* Normal */) {
+      return this.deleteToEnd();
+    }
+    const graphemes = splitGraphemes(this.value);
+    let end = this.position;
+    while (end < graphemes.length) {
+      const g = graphemes[end];
+      if (g && isWhitespace(g)) {
+        end++;
+        continue;
+      }
+      break;
+    }
+    while (end < graphemes.length) {
+      const g = graphemes[end];
+      if (g && !isWhitespace(g)) {
+        end++;
+        continue;
+      }
+      break;
+    }
+    const before = graphemes.slice(0, this.position).join("");
+    const after = graphemes.slice(end).join("");
+    return this.#withValue(before + after, this.position);
+  }
+  /** Delete everything before the cursor. */
+  deleteToStart() {
+    const after = sliceGraphemes(this.value, this.position);
+    return this.#withValue(after, 0);
+  }
+  /** Delete everything after the cursor. */
+  deleteToEnd() {
+    const before = sliceGraphemes(this.value, 0, this.position);
+    return this.#withValue(before, before.length === 0 ? 0 : runeCount(before));
+  }
+  /** Reset to empty value and cursor at start. */
+  reset() {
+    return this.#withValue("", 0);
+  }
+  /** Replace the value and re-run validation. */
+  setValue(value) {
+    const sanitized = clampToLimit(sanitizeValue(value), this.charLimit);
+    return this.#withValue(
+      sanitized,
+      Math.min(this.position, runeCount(sanitized))
+    );
+  }
+  /** Run validation and return the error (if any). */
+  validate() {
+    return this.#runValidation(this.value);
+  }
+  /** Set a new validation function (re-validates current value). */
+  setValidateFunc(fn) {
+    const next = this.#with({ validateFn: fn });
+    return next.#withError(next.#runValidation(next.value));
+  }
+  /** Command to paste from the clipboard. */
+  paste() {
+    return [this, pasteCommand()];
+  }
+  /** Handle Tea messages (keys, cursor, paste). */
+  update(msg) {
+    let model = this;
+    const cmds = [];
+    if (msg instanceof tea.KeyMsg) {
+      if (model.focused) {
+        const [nextModel, keyCmd] = model.#handleKey(msg);
+        model = nextModel;
+        if (keyCmd) {
+          cmds.push(keyCmd);
+        }
+      }
+    } else if (msg instanceof PasteMsg) {
+      model = model.insertRunes(msg.text);
+    } else if (msg instanceof PasteErrorMsg) {
+      model = model.#withError(asError(msg.error));
+    }
+    const [cursor, cursorCmd] = model.cursor.update(msg);
+    model = model.#with({ cursor });
+    if (cursorCmd) {
+      cmds.push(cursorCmd);
+    }
+    return [model, tea.batch(...cmds)];
+  }
+  /** Render the input with prompt, text, and cursor. */
+  view() {
+    const promptRendered = this.promptStyle.inline(true).render(this.prompt);
+    const availableWidth = this.width > 0 ? Math.max(0, this.width - chapstick.width(promptRendered)) : Number.POSITIVE_INFINITY;
+    if (this.isEmpty() && this.placeholder) {
+      const placeholder = this.#placeholderView(availableWidth);
+      return promptRendered + placeholder;
+    }
+    const rendered = this.#valueView(availableWidth);
+    return promptRendered + rendered;
+  }
+  #handleKey(msg) {
+    let next = this;
+    let cmd = null;
+    const keyMap = this.keyMap;
+    switch (true) {
+      case key.matches(msg, keyMap.deleteWordBackward):
+        next = next.deleteWordLeft();
+        break;
+      case key.matches(msg, keyMap.deleteCharacterBackward):
+        next = next.deleteLeft();
+        break;
+      case key.matches(msg, keyMap.wordBackward):
+        next = next.wordLeft();
+        break;
+      case key.matches(msg, keyMap.characterBackward):
+        next = next.cursorLeft();
+        break;
+      case key.matches(msg, keyMap.wordForward):
+        next = next.wordRight();
+        break;
+      case key.matches(msg, keyMap.characterForward):
+        next = next.cursorRight();
+        break;
+      case key.matches(msg, keyMap.lineStart):
+        next = next.cursorStart();
+        break;
+      case key.matches(msg, keyMap.deleteCharacterForward):
+        next = next.deleteRight();
+        break;
+      case key.matches(msg, keyMap.lineEnd):
+        next = next.cursorEnd();
+        break;
+      case key.matches(msg, keyMap.deleteAfterCursor):
+        next = next.deleteToEnd();
+        break;
+      case key.matches(msg, keyMap.deleteBeforeCursor):
+        next = next.deleteToStart();
+        break;
+      case key.matches(msg, keyMap.paste):
+        cmd = pasteCommand();
+        break;
+      case key.matches(msg, keyMap.deleteWordForward):
+        next = next.deleteWordRight();
+        break;
+      default:
+        if ((msg.key.type === tea.KeyType.Runes || msg.key.type === tea.KeyType.Space) && !msg.key.alt) {
+          next = next.insertRunes(msg.key.runes);
+        }
+        break;
+    }
+    return [next, cmd];
+  }
+  #placeholderView(availableWidth) {
+    const graphemes = splitGraphemes(this.placeholder);
+    const cursorChar = graphemes[0] ?? " ";
+    const rest = graphemes.slice(1).join("");
+    const budget = Number.isFinite(availableWidth) ? Math.max(0, availableWidth - chapstick.width(cursorChar)) : void 0;
+    const visibleRest = budget === void 0 ? rest : chapstick.clampWidth(rest, budget);
+    const cursorView = this.cursor.withChar(cursorChar || " ").view();
+    const styledRest = this.placeholderStyle.inline(true).render(visibleRest);
+    const usedWidth = chapstick.width(cursorChar + visibleRest);
+    const padding = Number.isFinite(availableWidth) && availableWidth > 0 ? Math.max(0, availableWidth - usedWidth) : 0;
+    return cursorView + styledRest + " ".repeat(padding);
+  }
+  #valueView(availableWidth) {
+    const graphemes = splitGraphemes(this.value);
+    const displayGraphemes = graphemes.map((g) => this.#echoTransform(g));
+    const widths = displayGraphemes.map((g) => chapstick.width(g));
+    const [start, end] = visibleRange(widths, this.position, availableWidth);
+    const slice = displayGraphemes.slice(start, end);
+    const cursorOffset = clamp(this.position - start, 0, slice.length);
+    const before = slice.slice(0, cursorOffset).join("");
+    const after = cursorOffset < slice.length ? slice.slice(cursorOffset + 1).join("") : "";
+    const cursorChar = cursorOffset < slice.length ? slice[cursorOffset] ?? " " : " ";
+    const beforeStyled = this.textStyle.inline(true).render(before);
+    const afterStyled = this.textStyle.inline(true).render(after);
+    const cursorView = this.cursor.withChar(cursorChar || " ").view();
+    const usedWidth = chapstick.width(before) + chapstick.width(cursorChar || " ") + chapstick.width(after);
+    const padding = Number.isFinite(availableWidth) && availableWidth > 0 ? Math.max(0, availableWidth - usedWidth) : 0;
+    return beforeStyled + cursorView + afterStyled + " ".repeat(padding);
+  }
+  #echoTransform(s) {
+    switch (this.echoMode) {
+      case "password" /* Password */:
+        return this.echoCharacter.repeat(Math.max(0, runeCount(s)));
+      case "none" /* None */:
+        return "";
+      case "normal" /* Normal */:
+      default:
+        return s;
+    }
+  }
+  #withPosition(position) {
+    const clamped = clamp(position, 0, this.length());
+    if (clamped === this.position) {
+      return this;
+    }
+    return this.#with({ position: clamped });
+  }
+  #withValue(value, position) {
+    const clamped = clampToLimit(value, this.charLimit);
+    const pos = clamp(position ?? this.position, 0, runeCount(clamped));
+    const next = this.#with({ value: clamped, position: pos });
+    return next.#withError(next.#runValidation(clamped));
+  }
+  #withError(error) {
+    if (error === this.error) {
+      return this;
+    }
+    return this.#with({ error });
+  }
+  #with(patch) {
+    return new _TextInputModel({
+      value: this.value,
+      position: this.position,
+      focused: this.focused,
+      placeholder: this.placeholder,
+      echoMode: this.echoMode,
+      echoCharacter: this.echoCharacter,
+      charLimit: this.charLimit,
+      width: this.width,
+      prompt: this.prompt,
+      promptStyle: this.promptStyle,
+      textStyle: this.textStyle,
+      placeholderStyle: this.placeholderStyle,
+      cursorStyle: this.cursorStyle,
+      validateFn: this.validateFn,
+      keyMap: this.keyMap,
+      cursor: this.cursor,
+      error: this.error,
+      ...patch
+    });
+  }
+  #runValidation(value) {
+    return this.validateFn ? this.validateFn(value) : null;
+  }
+  #remainingCapacity(current) {
+    if (this.charLimit <= 0) {
+      return Number.POSITIVE_INFINITY;
+    }
+    const remaining = this.charLimit - runeCount(current);
+    return Math.max(0, remaining);
+  }
+};
+function sanitizeValue(value) {
+  return sanitizer.sanitize(value ?? "");
+}
+function clampToLimit(value, charLimit) {
+  if (charLimit <= 0) {
+    return value;
+  }
+  return clampGraphemes(value, charLimit);
+}
+function clampGraphemes(value, limit) {
+  if (limit <= 0) {
+    return "";
+  }
+  const graphemes = splitGraphemes(value);
+  if (graphemes.length <= limit) {
+    return graphemes.join("");
+  }
+  return graphemes.slice(0, limit).join("");
+}
+function splitGraphemes(value) {
+  return splitter.splitGraphemes(value ?? "");
+}
+function sliceGraphemes(value, start, end) {
+  const graphemes = splitGraphemes(value);
+  return graphemes.slice(start, end).join("");
+}
+function runeCount(value) {
+  return splitter.countGraphemes(value ?? "");
+}
+function clamp(value, min, max) {
+  const lower = Math.min(min, max);
+  const upper = Math.max(min, max);
+  return Math.min(upper, Math.max(lower, value));
+}
+function isWhitespace(grapheme) {
+  return /^\s+$/.test(grapheme);
+}
+function visibleRange(widths, position, maxWidth) {
+  const len = widths.length;
+  if (!Number.isFinite(maxWidth) || maxWidth <= 0) {
+    return [0, len];
+  }
+  if (len === 0) {
+    return [0, 0];
+  }
+  const widthAt = (i) => i >= 0 && i < len ? widths[i] ?? 0 : 0;
+  const budget = maxWidth;
+  let start = Math.min(position, len);
+  let end = start;
+  let current = 0;
+  if (position < len) {
+    current = widthAt(position);
+    start = position;
+    end = position + 1;
+  } else {
+    current = 1;
+  }
+  while (start > 0) {
+    const w = widthAt(start - 1);
+    if (current > 0 && current + w > budget) {
+      break;
+    }
+    start--;
+    current += w;
+    if (current >= budget) {
+      break;
+    }
+  }
+  while (end < len) {
+    const w = widthAt(end);
+    if (current > 0 && current + w > budget) {
+      break;
+    }
+    end++;
+    current += w;
+    if (current >= budget) {
+      break;
+    }
+  }
+  while (current > budget && start < end) {
+    current -= widthAt(start);
+    start++;
+  }
+  return [start, end];
+}
+function asError(err) {
+  if (err instanceof Error) {
+    return err;
+  }
+  if (typeof err === "string") return new Error(err);
+  if (typeof err === "number" || typeof err === "boolean")
+    return new Error(String(err));
+  return new Error("clipboard error");
+}
+
+Object.defineProperty(exports, "CursorMode", {
+  enumerable: true,
+  get: function () { return cursor.CursorMode; }
+});
+exports.EchoMode = EchoMode;
+exports.PasteErrorMsg = PasteErrorMsg;
+exports.PasteMsg = PasteMsg;
+exports.TextInputModel = TextInputModel;
+exports.defaultKeyMap = defaultKeyMap;
+exports.pasteCommand = pasteCommand;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map