tunli 0.0.19

package/src/cli-app/elements/List/List.js

@@ -0,0 +1,227 @@
+import {isRef} from "#src/core/Ref";
+import blessed from 'blessed';
+import {ListColumn} from "#src/cli-app/elements/List/ListColumn";
+import {ListCell} from "#src/cli-app/elements/List/ListCell";
+import {ListRow} from "#src/cli-app/elements/List/ListRow";
+import {ElementNode} from "#src/cli-app/elements/ElementNode";
+import {padEndIgnoreControlChars} from "#src/utils/stringFunctions";
+
+export class List extends ElementNode {
+
+  /**
+   * @type {Screen}
+   */
+  #screen
+  #box
+  /**
+   * @type {ListRow[]}
+   */
+  #rows = []
+  /**
+   * @type {ListColumn[]}
+   */
+  #columns = []
+  #needsUpdate = false
+
+  /**
+   * @type {cliListOption}
+   */
+  #options = {}
+
+  /**
+   * @param {cliListOption} [options]
+   */
+  init(options) {
+
+    options ??= {}
+    this.#options.length = options.length
+    this.#options.maxLength = options.maxLength ?? this.#options.length
+    this.#options.minLength = options.minLength ?? options.maxLength ?? this.#options.length ?? 0
+    this.#options.minWidth = options.minWidth ?? 0
+    this.#options.maxWidth = options.maxWidth ?? Infinity
+    this.#options.reverse = options.reverse === true
+    this.#screen = this.screen
+
+    this.height = this.#options.minLength
+
+    this.on('position-top', (val) => this.#box.top = val)
+    this.on('height', (val) => this.#box.height = val)
+    this.on('delete', () => this.#box.detach())
+
+    this.#box = blessed.box({
+      top: this.positionTop,
+      // top: 'center',
+      left: 'center',
+      width: '100%',
+      height: this.#options.minLength,
+      content: '',
+      tags: true,
+      // border: {
+      //   type: 'line'
+      // },
+      // style: {   // TODO MOVE TO PRESETS
+      //   fg: 'white',
+      //   bg: 'blue',
+      //   border: {
+      //     fg: '#f0f0f0'
+      //   },
+      // }
+    });
+
+    this.#screen.append(this.#box)
+  }
+
+  /**
+   * @param {ListRow} row
+   * @return {string}
+   */
+  #formatRow(row) {
+    let contentRow = ``
+
+    const lastCell = row.lastCell
+
+    for (const cell of row.cells) {
+
+      if (cell !== lastCell) {
+        const cellWidth = this.#calWidth(cell)
+        contentRow += padEndIgnoreControlChars(cell.content, cellWidth - 1, ' ', '...') + ' '
+      }
+    }
+
+    contentRow += `${lastCell.content}`
+    return contentRow
+  }
+
+
+  /**
+   * @returns {?ListRow}
+   */
+  row(...content) {
+
+    if (this.detached) {
+      return null
+    }
+
+    this.#needsUpdate = false
+    // ACTUNG ES  MÜSSEN SÄMTLICHE REFERNEZNE GELÖSCHT WEWRDEN DELETE CASCADE
+    const cells = content.map((x, index) => {
+      this.#columns[index] ??= (new ListColumn()).on('width-change', (newValue, oldValue) => {
+        this.#needsUpdate = true
+      })
+      return new ListCell(x, this.#columns[index], index)
+    })
+
+    for (let i = 0; i < cells.length; i++) {
+      if (isRef(content[i])) {
+        content[i].on('update', (value) => {
+          const cell = cells[i]
+          const widthBefore = cell.column.width
+          cell.content = value
+          const needsUpdate = widthBefore !== cell.column.width
+
+          if (needsUpdate) {
+            this.#render(needsUpdate)
+          } else {
+            this.#updateRow(cell.row)
+          }
+          this.#screen.render()
+        })
+      }
+    }
+
+    const rowNodeBefore = this.#rows[this.#rows.length - 1]
+    const rowNew = new ListRow(cells, rowNodeBefore)
+
+    this.#rows.push(rowNew)
+
+    let append = true
+
+    if (this.#options.maxLength) {
+      this.#needsUpdate = true
+      const delRows = this.#rows.splice(0, this.#rows.length - this.#options.maxLength)
+      append = !delRows.length
+      for (const del of delRows) {
+        del.delete()
+      }
+    }
+
+    rowNew.on('delete', (/** ListRow */ row) => {
+      this.#box.deleteLine(row.lineNumber)
+
+      if (this.#rows[row.lineNumber] === row) {
+        delete this.#rows[row.lineNumber]
+      }
+    }).on('hide', () => {
+      this.#render(true)
+      this.screen.render()
+    }).on('show', () => {
+      this.#render(true)
+      this.screen.render()
+    })
+
+    this.#render(this.#needsUpdate, append)
+
+    return rowNew
+  }
+
+  /**
+   * @param {ListRow} row
+   */
+  #updateRow(row) {
+    let spacing = 1
+
+    this.#box.setLine(row.lineNumber, this.#formatRow(row))
+    // this.#screen.render()
+  }
+
+  /**
+   * @param {ListCell} cell
+   */
+  #calWidth(cell) {
+    const spacing = 1
+    let set = this.#options.minWidth
+    let max = this.#options.maxWidth
+
+    if (Array.isArray(this.#options.minWidth)) {
+      set = this.#options.minWidth[cell.index]
+    }
+    if (Array.isArray(this.#options.maxWidth)) {
+      max = this.#options.maxWidth[cell.index]
+    }
+
+    return Math.min(
+      max ?? Infinity,
+      Math.max(
+        set ?? 0,
+        cell.column.width + spacing
+      ))
+  }
+
+  #render(needsUpdate, append) {
+
+    this.#rows = this.#rows.filter(x => !x.deleted)
+    const rows = this.#rows
+    const visibleRows = this.#rows.filter(row => !row.hidden)
+
+    if (append) {
+      this.#box.insertLine(visibleRows.length - 1, this.#formatRow(rows[rows.length - 1]))
+    }
+
+    if (needsUpdate) {
+      for (let i = 0; i < visibleRows.length; i++) {
+        const rowId = this.#options.reverse ? visibleRows.length - 1 - i : i
+        this.#box.setLine(i, this.#formatRow(visibleRows[rowId]))
+      }
+    }
+
+    this.height = Math.max(visibleRows.length + 2, this.#options.minLength + 2)// border top bottom
+
+    // Clear empty lines
+
+    for (let i = visibleRows.length; i < this.height; i++) {
+      this.#box.setLine(i, '')
+    }
+
+    this.screen.updateElement(this)
+  }
+}

package/src/cli-app/elements/List/ListCell.js

@@ -0,0 +1,83 @@
+import {isRef} from "#src/core/Ref";
+import {removeControlChars} from "#src/utils/stringFunctions";
+
+export class ListCell {
+  /**
+   * @type {string}
+   */
+  #content
+  /**
+   * @type {ListColumn}
+   */
+  #column
+
+  /**
+   * @type {ListRow}
+   */
+  #row
+
+  #contentLength
+
+  /**
+   *
+   * @param content
+   * @param {ListColumn} column
+   */
+  constructor(content, column, index) {
+
+    this.index = index
+    if (isRef(content)) {
+      content = content.value
+    }
+
+    content ??= ''
+
+    const toc = typeof content
+
+    if (toc === 'number') {
+      content = content.toString()
+    } else if (toc !== 'string') {
+      if (content) {
+        content = content.toString()
+      } else {
+        content = 'INVALID_STRING'
+      }
+    }
+
+    this.#contentLength = removeControlChars(content).length
+    this.#content = content
+    this.#column = column
+    this.#column.push(this)
+  }
+
+  get row() {
+    return this.#row
+  }
+
+  set row(row) {
+    this.#row = row
+  }
+
+  get contentLength() {
+    return this.#contentLength
+  }
+
+  get content() {
+    return this.#content;
+  }
+
+  set content(value) {
+    this.#content = value;
+  }
+
+  /**
+   * @return {ListColumn}
+   */
+  get column() {
+    return this.#column
+  }
+
+  delete() {
+    this.column.deleteCell(this)
+  }
+}

package/src/cli-app/elements/List/ListColumn.js

@@ -0,0 +1,52 @@
+import EventEmitter from "node:events";
+import {arrayRemoveEntry} from "#src/utils/arrayFunctions";
+
+export class ListColumn extends EventEmitter {
+
+  /**
+   *
+   * @type {ListCell[]}
+   */
+  #cells = []//new Set()
+
+  #width
+  /**
+   * @return {number}
+   */
+  get width() {
+    // CACHING VIA UPDATE EVENT FROM CELLS?
+    const tmp = Math.max(...this.#cells.map(x => x.contentLength))
+
+    if (tmp < 0) {
+      return 0
+    }
+
+    return tmp
+  }
+
+  /**
+   * @param {ListCell} cell
+   */
+  deleteCell(cell) {
+    const before = this.width
+    this.#cells = arrayRemoveEntry(this.#cells, cell)
+    const now = this.width
+    if (now !== before) {
+      this.emit('width-change', now, before)
+    }
+  }
+
+  /**
+   *
+   * @param {ListCell} cell
+   */
+  push(cell) {
+    const before = this.width
+    this.#cells.push(cell)//, cell.content.length)
+    const now = this.width
+
+    if (now !== before) {
+      this.emit('width-change', now, before)
+    }
+  }
+}

package/src/cli-app/elements/List/ListRow.js

@@ -0,0 +1,118 @@
+import EventEmitter from "node:events";
+import {ListCell} from "#src/cli-app/elements/List/ListCell";
+import {isRef} from "#src/core/Ref";
+
+export class ListRow extends EventEmitter {
+
+  /**
+   * @param {ListCell[]} cells
+   */
+  #cells
+
+  /**
+   * @type {number}
+   */
+  #lineNumber
+  /**
+   * @type {ListRow}
+   */
+  #_rowBefore
+  #deleted = false
+  #hidden = false
+
+  /**
+   * @param {ListCell[]} cells
+   */
+  constructor(cells, rowNodeBefore) {
+    super()
+    this.#cells = cells
+    this.#rowBefore = rowNodeBefore
+
+    this.#rowBefore?.on('delete', (rowBefore) => {
+      this.#rowBefore = rowBefore?.#rowBefore
+    })
+
+    cells.forEach(cell => cell.row = this)
+  }
+
+  /**
+   * @returns {ListRow}
+   */
+  get #rowBefore() {
+    if (this.#_rowBefore?.hidden) {
+      return this.#_rowBefore.#rowBefore
+    }
+
+    return this.#_rowBefore
+  }
+
+  /**
+   * @param {ListRow} rowBefore
+   */
+  set #rowBefore(rowBefore) {
+    this.#_rowBefore = rowBefore
+  }
+
+  get length() {
+    return this.#cells.length
+  }
+
+  get lineNumber() {
+    if (this.#rowBefore) {
+      return this.#rowBefore?.lineNumber + 1
+    }
+    return 0
+  }
+
+  get deleted() {
+    return this.#deleted
+  }
+
+  /**
+   * @return {ListCell[]}
+   */
+  get cells() {
+    return this.#cells
+  }
+
+  /**
+   * @return {ListCell}
+   */
+  get lastCell() {
+    return this.#cells[this.#cells.length - 1]
+  }
+
+  get hidden() {
+    return this.#hidden
+  }
+
+  set hidden(hidden) {
+
+    if (this.#hidden === hidden) {
+      return
+    }
+
+    this.#hidden = hidden
+    this.emit(hidden ? 'hide' : 'show')
+  }
+
+  if(renderIfCallback) {
+    const result = renderIfCallback()
+    if (isRef(result)) {
+      result.on('update', (val) => this.hidden = !val)
+      this.hidden = !result.value
+    } else {
+      this.hidden = !result
+    }
+    return this
+  }
+
+  delete() {
+    this.#deleted = true
+
+    for (const cell of this.#cells) {
+      cell.delete()
+    }
+    this.emit('delete', this)
+  }
+}

package/src/cli-app/elements/Row.js

@@ -0,0 +1,38 @@
+import blessed from 'blessed';
+import {ElementNode} from "#src/cli-app/elements/ElementNode";
+
+export class Row extends ElementNode {
+
+  #content
+  #row
+
+  set content(content) {
+    this.height = content.split("\n").length
+    this.#row.content = content
+    this.screen.updateElement(this)
+  }
+
+  /**
+   * @param {string|Ref} content
+   */
+  init(content, {top, right}) {
+
+    this.offsetTop = top
+
+    this.#content = content
+    // this.#rowBefore = rowNodeBefore
+    this.#row = blessed.text({
+      top: this.positionTop,
+      right,
+      content
+    })
+
+    this.height = 1
+
+    this.on('position-top', (val) => this.#row.top = val)
+    this.on('height', (val) => this.#row.height = val)
+    this.on('delete', (val) => this.#row.detach())
+
+    this.screen.append(this.#row)
+  }
+}

package/src/cli-app/helper/utils.js

@@ -0,0 +1,42 @@
+import blessed from 'blessed';
+import {Screen} from "#src/cli-app/Screen";
+import {isRef, ref} from "#src/core/Ref";
+
+/**
+ * @param {string} [title]
+ * @returns {Screen}
+ */
+export const createScreen = (title) => {
+  const screen = blessed.screen({
+    smartCSR: true,
+    title
+  });
+  return new Screen(screen)
+}
+
+/**
+ * @param {string|Ref|number} values
+ * @returns {Ref}
+ */
+export const concat = (...values) => {
+
+  const update = () => {
+    finalValue.value = values.map((x) => {
+
+
+      return x.value
+    }).join('')
+  }
+
+  const finalValue = ref()
+  values = values.map(value => {
+    if (!isRef(value)) {
+      return ref(value)
+    } else {
+      value.on('update', update)
+    }
+    return value
+  })
+  update()
+  return finalValue
+}

package/src/commands/Action/addDelValuesAction.js

@@ -0,0 +1,56 @@
+import {arrayMerge, arraySub, arrayUnique} from "#src/utils/arrayFunctions";
+
+/**
+ * @param configKey
+ * @param {Ref} configRef
+ * @returns {(function(*, {add: *, del: *}): void)|*}
+ */
+export const addDelValuesAction = (configKey, configRef) => {
+
+  return (argValues, {add, del}) => {
+
+    /** @type {LocalConfig|GlobalConfig} */
+    const config = configRef.value
+
+    if (!argValues.length && !del && !add) {
+      console.log(config[configKey].join(', '))
+      return
+    }
+
+    if (!argValues.length) {
+      argValues = config[configKey]
+    }
+
+    argValues = arrayUnique(arraySub(arrayMerge(argValues, add), del))
+    config[configKey] = argValues
+    config.save()
+  }
+}
+
+/**
+ * @param configKey
+ * @param configRef
+ * @returns {(function(*, {add: *, del: *}): void)|*}
+ */
+export const addGetDeleteValueAction = (configKey, configRef) => {
+
+  return (value, opts) => {
+
+    /** @type {LocalConfig|GlobalConfig} */
+    const config = configRef.value
+
+    if (opts.del) {
+      config.del(configKey)
+      config.save()
+      return;
+    }
+
+    if (value === undefined) {
+      console.log(config[configKey])
+      return
+    }
+
+    config[configKey] = value
+    config.save()
+  }
+}

package/src/commands/CommandAuth.js

@@ -0,0 +1,32 @@
+import {Command} from "commander";
+import {addExample, extendUsage} from "#commands/utils";
+import {ConfigManager} from "#src/config/ConfigManager";
+
+/**
+ * @returns {(function(): void)|*}
+ */
+const exec = () => {
+
+  return async (token) => {
+    const config = ConfigManager.loadSystem()
+    config.authToken = token
+    config.save()
+    console.log('Done.')
+  }
+}
+
+/**
+ *
+ * @param {Command} program
+ */
+export const createCommandAuth = (program) => {
+
+  const cmd = new Command('auth')
+    .argument('<token>', 'auth token')
+    .action(exec())
+
+  extendUsage(program, cmd)
+  addExample('auth <TOKEN>', 'register this client with given token')
+  return cmd
+
+}

package/src/commands/CommandClearAll.js

@@ -0,0 +1,27 @@
+import {searchDirInDirectoryTree} from "#lib/FS/utils";
+import {CONFIG_DIR_NAME} from "#lib/defs";
+
+/**
+ *
+ * @param {Command} program
+ * @returns {(function(): void)|*}
+ */
+const exec = (program) => {
+
+  return async() => {
+
+    let path
+    while (null !== (path = searchDirInDirectoryTree(CONFIG_DIR_NAME))) {
+      console.log(`remove ${path}`)
+      await rm(path, {recursive: true, force: true})
+    }
+  }
+}
+/**
+ * @param {Command} program
+ */
+export const addCommandClearAll = (program) => {
+  program.command('clear-all')
+    .description('Remove all configurations in directory tree including global')
+    .action(exec(program))
+}